Repository navigation
fix: show pack search errors with retry and close legacy-manager tip and search edge cases - #21154
Conversation
toRepoName and the rewrite comparison trimmed before dropping trailing slashes, so 'kijai/comfyui-kjnodes /' kept its owner and a trailing space, 'comfyui-kjnodes /' sent a rewrite that only lost the slash, and 'ltdrdata/ComfyUI-Manager /' missed the legacy-manager tip.
doLoadMore only logged a failed search to the console, so an outage of every search provider showed as an empty result and never reached telemetry. It now goes through reportError; the UI is unchanged.
firstPage only recorded the query, so a nodes-mode ComfyUI-Manager search that landed after the switch to packs mode could still show the tip. useRegistrySearch now records the mode each first page was searched in, and ManagerDialog only shows the tip when it matches the live mode.
On a filtered tab such as Installed, the tip only looked for the ComfyUI-Manager pack among the packs the tab shows. When the search found the pack but the tab filtered it away, the tip still showed. It now checks the raw search results instead.
analyticsTags are left out of the pack search cache key, so a query served from the cache sends no request and records no analytics event.
|
Important Review skippedBot user detected. To trigger a single review, invoke the ⚙️ Run configuration
You can disable this status message by setting the Use the checkbox below for a quick retry:
Comment |
📦 Bundle: 11.6 MB gzip 🔴 +865 BDetailsSummary
Category Glance App Entry Points — 6.95 kB (baseline 6.95 kB) • ⚪ 0 BMain entry bundles and manifests
Status: 1 added / 1 removed Graph Workspace — 3.39 MB (baseline 3.39 MB) • 🔴 +4.37 kBGraph editor runtime, canvas, workflow orchestration
Status: 3 added / 3 removed / 1 unchanged Views & Navigation — 147 kB (baseline 147 kB) • ⚪ 0 BTop-level views, pages, and routed surfaces
Status: 15 added / 15 removed / 3 unchanged Panels & Settings — 784 kB (baseline 784 kB) • ⚪ 0 BConfiguration panels, inspectors, and settings screens
Status: 14 added / 14 removed / 20 unchanged User & Accounts — 153 kB (baseline 153 kB) • ⚪ 0 BAuthentication, profile, and account management bundles
Status: 9 added / 9 removed / 8 unchanged Editors & Dialogs — 362 kB (baseline 362 kB) • ⚪ 0 BModals, dialogs, drawers, and in-app editors
Status: 8 added / 8 removed / 5 unchanged UI Components — 225 kB (baseline 225 kB) • ⚪ 0 BReusable component library chunks
Status: 9 added / 9 removed / 21 unchanged Data & Services — 1.2 MB (baseline 1.2 MB) • ⚪ 0 BStores, services, APIs, and repositories
Status: 33 added / 33 removed / 10 unchanged Utilities & Hooks — 1.01 MB (baseline 1.01 MB) • 🟢 -36 BHelpers, composables, and utility bundles
Status: 37 added / 37 removed / 40 unchanged Vendor & Third-Party — 24.7 MB (baseline 24.7 MB) • 🔴 +166 BExternal libraries and shared vendor chunks
Status: 1 added / 1 removed / 16 unchanged Other — 20.6 MB (baseline 20.6 MB) • ⚪ 0 BBundles that do not match a named category
Status: 108 added / 108 removed / 579 unchanged ⚡ Performance Report
Scenario timings
Show regressions
All metrics
Historical variance (last 15 runs)
Trend (last 15 commits on main)
Raw data{
"timestamp": "2026-10-19T03:56:10.780Z",
"gitSha": "d76f5e043bbd7e3e1ce128f37cb8d3ad9d549b32",
"branch": "search/pack-search-review4-followup",
"measurements": [
{
"name": "canvas-idle",
"durationMs": 2024.8470000000225,
"styleRecalcs": 9,
"styleRecalcDurationMs": 3.224,
"layouts": 9,
"layoutDurationMs": 3.013,
"taskDurationMs": 451.24199999999996,
"heapDeltaBytes": -8704048,
"heapUsedBytes": 95043752,
"domNodes": -180,
"jsHeapTotalBytes": 2265088,
"scriptDurationMs": 11.566999999999997,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.66639344262295,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "canvas-idle",
"durationMs": 2040.1500000000397,
"styleRecalcs": 10,
"styleRecalcDurationMs": 3.359,
"layouts": 10,
"layoutDurationMs": 3.609,
"taskDurationMs": 629.8340000000001,
"heapDeltaBytes": -13821636,
"heapUsedBytes": 90332252,
"domNodes": -200,
"jsHeapTotalBytes": 2265088,
"scriptDurationMs": 11.288,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.66639344262295,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "canvas-mouse-sweep",
"durationMs": 1760.7430000000477,
"styleRecalcs": 74,
"styleRecalcDurationMs": 13.913000000000002,
"layouts": 9,
"layoutDurationMs": 2.378,
"taskDurationMs": 841.2610000000001,
"heapDeltaBytes": -12419012,
"heapUsedBytes": 91660672,
"domNodes": -200,
"jsHeapTotalBytes": 3313664,
"scriptDurationMs": 169.371,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666981132075474,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "canvas-mouse-sweep",
"durationMs": 1875.6329999999934,
"styleRecalcs": 80,
"styleRecalcDurationMs": 15.344999999999999,
"layouts": 10,
"layoutDurationMs": 2.7790000000000004,
"taskDurationMs": 941.5409999999999,
"heapDeltaBytes": -2887480,
"heapUsedBytes": 95595132,
"domNodes": 0,
"jsHeapTotalBytes": 7602176,
"scriptDurationMs": 172.673,
"eventListeners": 6,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666071428571424,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "canvas-zoom-sweep",
"durationMs": 1723.1120000000146,
"styleRecalcs": 20,
"styleRecalcDurationMs": 6.729,
"layouts": 10,
"layoutDurationMs": 3.548,
"taskDurationMs": 501.08200000000005,
"heapDeltaBytes": -802528,
"heapUsedBytes": 90869920,
"domNodes": 47,
"jsHeapTotalBytes": 6553600,
"scriptDurationMs": 17.985000000000003,
"eventListeners": 37,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.66601941747573,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "canvas-zoom-sweep",
"durationMs": 1725.3670000000056,
"styleRecalcs": 18,
"styleRecalcDurationMs": 5.896999999999999,
"layouts": 11,
"layoutDurationMs": 3.533,
"taskDurationMs": 381.9560000000001,
"heapDeltaBytes": 1827984,
"heapUsedBytes": 106052844,
"domNodes": 47,
"jsHeapTotalBytes": 7602176,
"scriptDurationMs": 16.962,
"eventListeners": 37,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666346153846156,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "dom-widget-clipping",
"durationMs": 693.478999999968,
"styleRecalcs": 13,
"styleRecalcDurationMs": 2.993,
"layouts": 9,
"layoutDurationMs": 2.247,
"taskDurationMs": 497.8230000000001,
"heapDeltaBytes": 8198108,
"heapUsedBytes": 114363700,
"domNodes": 0,
"jsHeapTotalBytes": 14155776,
"scriptDurationMs": 166.73399999999998,
"eventListeners": 0,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.665853658536566,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "dom-widget-clipping",
"durationMs": 619.735999999989,
"styleRecalcs": 14,
"styleRecalcDurationMs": 3.194,
"layouts": 10,
"layoutDurationMs": 3.015,
"taskDurationMs": 448.02200000000005,
"heapDeltaBytes": 4462632,
"heapUsedBytes": 103734584,
"domNodes": 0,
"jsHeapTotalBytes": 7340032,
"scriptDurationMs": 170.08700000000002,
"eventListeners": 0,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.667567567567563,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "dom-widget-order-dense-n200-w200-i120",
"durationMs": 1259.6239999999739,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 923.7769999999999,
"heapDeltaBytes": -7875292,
"heapUsedBytes": 102382556,
"domNodes": -210,
"jsHeapTotalBytes": 9875456,
"scriptDurationMs": 72.93699999999998,
"eventListeners": -168,
"totalBlockingTimeMs": 575,
"frameDurationMs": 34.23243243243244,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "dom-widget-order-dense-n200-w200-i120",
"durationMs": 1210.4809999999588,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 925.079,
"heapDeltaBytes": -15530876,
"heapUsedBytes": 102186848,
"domNodes": -230,
"jsHeapTotalBytes": 13611008,
"scriptDurationMs": 74.22499999999998,
"eventListeners": -168,
"totalBlockingTimeMs": 527,
"frameDurationMs": 32.88108108108109,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "dom-widget-order-sparse-n1000-w20-i120",
"durationMs": 877.3160000000075,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 530.7550000000001,
"heapDeltaBytes": -2846332,
"heapUsedBytes": 97297548,
"domNodes": 0,
"jsHeapTotalBytes": 0,
"scriptDurationMs": 165.01699999999997,
"eventListeners": 0,
"totalBlockingTimeMs": 245,
"frameDurationMs": 25.979411764705887,
"p95FrameDurationMs": 16.80000000000109
},
{
"name": "dom-widget-order-sparse-n1000-w20-i120",
"durationMs": 856.1369999999897,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 450.898,
"heapDeltaBytes": -3917380,
"heapUsedBytes": 97503152,
"domNodes": 0,
"jsHeapTotalBytes": 0,
"scriptDurationMs": 159.379,
"eventListeners": 0,
"totalBlockingTimeMs": 220,
"frameDurationMs": 24.99705882352943,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "extension-clean-combined-draw",
"durationMs": 11198.813999999998,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 10215.715,
"heapDeltaBytes": -1992176,
"heapUsedBytes": 119189384,
"domNodes": -276,
"jsHeapTotalBytes": -880640,
"scriptDurationMs": 8564.325,
"eventListeners": -130,
"totalBlockingTimeMs": 1566,
"frameDurationMs": 32.556976744186045,
"p95FrameDurationMs": 66.69999999999891
},
{
"name": "extension-clean-combined-draw",
"durationMs": 9326.395999999988,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 8531.830999999998,
"heapDeltaBytes": -26438156,
"heapUsedBytes": 94652964,
"domNodes": -276,
"jsHeapTotalBytes": -880640,
"scriptDurationMs": 7147.780999999999,
"eventListeners": -130,
"totalBlockingTimeMs": 790,
"frameDurationMs": 32.01477663230241,
"p95FrameDurationMs": 50.100000000000364
},
{
"name": "extension-rgthree-prototype-draw",
"durationMs": 11823.154999999986,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 10911.538,
"heapDeltaBytes": 32986340,
"heapUsedBytes": 145876184,
"domNodes": -276,
"jsHeapTotalBytes": 35098624,
"scriptDurationMs": 8728.733,
"eventListeners": -130,
"totalBlockingTimeMs": 1706,
"frameDurationMs": 31.554133333333333,
"p95FrameDurationMs": 66.69999999999891
},
{
"name": "extension-rgthree-prototype-draw",
"durationMs": 11310.22900000005,
"styleRecalcs": 1,
"styleRecalcDurationMs": 0.037000000000000574,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 10513.399,
"heapDeltaBytes": 18985772,
"heapUsedBytes": 140844208,
"domNodes": -296,
"jsHeapTotalBytes": 44208128,
"scriptDurationMs": 8422.599,
"eventListeners": -130,
"totalBlockingTimeMs": 1289,
"frameDurationMs": 31.088736263736255,
"p95FrameDurationMs": 50.100000000000364
},
{
"name": "large-combo-open",
"durationMs": 268.28199999999924,
"styleRecalcs": 24,
"styleRecalcDurationMs": 16.397,
"layouts": 12,
"layoutDurationMs": 4.078999999999999,
"taskDurationMs": 210.939,
"heapDeltaBytes": 13235744,
"heapUsedBytes": 118028264,
"domNodes": 917,
"jsHeapTotalBytes": 2097152,
"scriptDurationMs": 10.349,
"eventListeners": 196,
"totalBlockingTimeMs": 4,
"frameDurationMs": 26.660000000000036,
"p95FrameDurationMs": 100
},
{
"name": "large-combo-open",
"durationMs": 246.9269999999142,
"styleRecalcs": 26,
"styleRecalcDurationMs": 14.973,
"layouts": 12,
"layoutDurationMs": 3.9239999999999995,
"taskDurationMs": 189.57,
"heapDeltaBytes": 13305608,
"heapUsedBytes": 118260232,
"domNodes": 917,
"jsHeapTotalBytes": 2621440,
"scriptDurationMs": 8.966999999999999,
"eventListeners": 196,
"totalBlockingTimeMs": 5,
"frameDurationMs": 20.833333333333332,
"p95FrameDurationMs": 66.69999999999982
},
{
"name": "large-graph-idle",
"durationMs": 2057.4170000000436,
"styleRecalcs": 7,
"styleRecalcDurationMs": 2.974999999999999,
"layouts": 7,
"layoutDurationMs": 2.573,
"taskDurationMs": 541.686,
"heapDeltaBytes": 1894544,
"heapUsedBytes": 104253996,
"domNodes": -296,
"jsHeapTotalBytes": -4812800,
"scriptDurationMs": 35.053000000000004,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.80162601626016,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "large-graph-idle",
"durationMs": 2054.565000000025,
"styleRecalcs": 9,
"styleRecalcDurationMs": 2.9579999999999997,
"layouts": 9,
"layoutDurationMs": 2.8780000000000006,
"taskDurationMs": 698.8050000000001,
"heapDeltaBytes": -27273192,
"heapUsedBytes": 93020132,
"domNodes": -296,
"jsHeapTotalBytes": -1564672,
"scriptDurationMs": 33.588,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666666666666668,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "large-graph-pan",
"durationMs": 2861.352000000011,
"styleRecalcs": 69,
"styleRecalcDurationMs": 9.581000000000001,
"layouts": 7,
"layoutDurationMs": 1.9300000000000004,
"taskDurationMs": 1830.197,
"heapDeltaBytes": 617412,
"heapUsedBytes": 103726600,
"domNodes": -296,
"jsHeapTotalBytes": -131072,
"scriptDurationMs": 857.8240000000001,
"eventListeners": -128,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.76411764705883,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "large-graph-pan",
"durationMs": 2354.4239999999945,
"styleRecalcs": 67,
"styleRecalcDurationMs": 9.414,
"layouts": 6,
"layoutDurationMs": 1.5700000000000003,
"taskDurationMs": 1608.9759999999997,
"heapDeltaBytes": 6682220,
"heapUsedBytes": 109539608,
"domNodes": -276,
"jsHeapTotalBytes": -3276800,
"scriptDurationMs": 848.407,
"eventListeners": -128,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.7863309352518,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "large-graph-zoom",
"durationMs": 4087.8759999999943,
"styleRecalcs": 71,
"styleRecalcDurationMs": 10.388,
"layouts": 65,
"layoutDurationMs": 11.255,
"taskDurationMs": 1925.707,
"heapDeltaBytes": -11937216,
"heapUsedBytes": 94565824,
"domNodes": -252,
"jsHeapTotalBytes": 12685312,
"scriptDurationMs": 816.059,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666122448979596,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "large-graph-zoom",
"durationMs": 4153.998999999999,
"styleRecalcs": 69,
"styleRecalcDurationMs": 10.552999999999999,
"layouts": 63,
"layoutDurationMs": 10.92,
"taskDurationMs": 2018.332,
"heapDeltaBytes": -14294264,
"heapUsedBytes": 92356788,
"domNodes": -252,
"jsHeapTotalBytes": 12161024,
"scriptDurationMs": 854.8720000000001,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.665999999999997,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "legacy-node-drag",
"durationMs": 2992.2689999999648,
"styleRecalcs": 45,
"styleRecalcDurationMs": 5.706,
"layouts": 6,
"layoutDurationMs": 1.4529999999999998,
"taskDurationMs": 1851.34,
"heapDeltaBytes": 21054644,
"heapUsedBytes": 127299128,
"domNodes": 0,
"jsHeapTotalBytes": 6713344,
"scriptDurationMs": 1011.4940000000001,
"eventListeners": 182,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.759550561797752,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "legacy-node-drag",
"durationMs": 3245.6979999999476,
"styleRecalcs": 45,
"styleRecalcDurationMs": 5.34,
"layouts": 6,
"layoutDurationMs": 1.8239999999999996,
"taskDurationMs": 2167.883,
"heapDeltaBytes": -11318604,
"heapUsedBytes": 104087628,
"domNodes": -296,
"jsHeapTotalBytes": 2617344,
"scriptDurationMs": 1049.0919999999999,
"eventListeners": -127,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.838860103626946,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "minimap-idle",
"durationMs": 2055.7769999999778,
"styleRecalcs": 7,
"styleRecalcDurationMs": 2.3080000000000003,
"layouts": 7,
"layoutDurationMs": 2.1950000000000003,
"taskDurationMs": 768.297,
"heapDeltaBytes": -948056,
"heapUsedBytes": 102757312,
"domNodes": -296,
"jsHeapTotalBytes": -880640,
"scriptDurationMs": 38.242,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.665853658536584,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "minimap-idle",
"durationMs": 2053.062999999952,
"styleRecalcs": 7,
"styleRecalcDurationMs": 2.468999999999999,
"layouts": 6,
"layoutDurationMs": 2.3000000000000003,
"taskDurationMs": 792.67,
"heapDeltaBytes": -25345176,
"heapUsedBytes": 88496568,
"domNodes": -296,
"jsHeapTotalBytes": -1560576,
"scriptDurationMs": 39.19700000000001,
"eventListeners": -130,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.66585365853659,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "subgraph-dom-widget-clipping",
"durationMs": 713.7759999999957,
"styleRecalcs": 47,
"styleRecalcDurationMs": 5.800000000000001,
"layouts": 9,
"layoutDurationMs": 2.837,
"taskDurationMs": 503.35699999999997,
"heapDeltaBytes": 2694744,
"heapUsedBytes": 110637972,
"domNodes": 0,
"jsHeapTotalBytes": 13631488,
"scriptDurationMs": 150.74200000000002,
"eventListeners": 46,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666666666666668,
"p95FrameDurationMs": 16.699999999999818
},
{
"name": "subgraph-dom-widget-clipping",
"durationMs": 739.4259999999804,
"styleRecalcs": 46,
"styleRecalcDurationMs": 5.712999999999999,
"layouts": 8,
"layoutDurationMs": 2.6329999999999996,
"taskDurationMs": 512.357,
"heapDeltaBytes": 5232380,
"heapUsedBytes": 106758584,
"domNodes": 0,
"jsHeapTotalBytes": 12582912,
"scriptDurationMs": 157.125,
"eventListeners": 46,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.665909090909096,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "subgraph-idle",
"durationMs": 2042.8440000000023,
"styleRecalcs": 11,
"styleRecalcDurationMs": 3.49,
"layouts": 10,
"layoutDurationMs": 3.067,
"taskDurationMs": 483.32899999999995,
"heapDeltaBytes": -3984408,
"heapUsedBytes": 96673248,
"domNodes": -218,
"jsHeapTotalBytes": 6721536,
"scriptDurationMs": 11.481,
"eventListeners": -176,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.665853658536584,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "subgraph-idle",
"durationMs": 2012.8460000000814,
"styleRecalcs": 10,
"styleRecalcDurationMs": 3.7409999999999997,
"layouts": 10,
"layoutDurationMs": 3.902,
"taskDurationMs": 459.62399999999997,
"heapDeltaBytes": 3518496,
"heapUsedBytes": 95943748,
"domNodes": 0,
"jsHeapTotalBytes": 7602176,
"scriptDurationMs": 10.754,
"eventListeners": 0,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666115702479342,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "subgraph-mouse-sweep",
"durationMs": 1994.950000000017,
"styleRecalcs": 86,
"styleRecalcDurationMs": 14.905999999999999,
"layouts": 9,
"layoutDurationMs": 2.7279999999999998,
"taskDurationMs": 991.999,
"heapDeltaBytes": -17871516,
"heapUsedBytes": 88356272,
"domNodes": -210,
"jsHeapTotalBytes": 3051520,
"scriptDurationMs": 116.398,
"eventListeners": -174,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.66666666666667,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "subgraph-mouse-sweep",
"durationMs": 1840.498000000025,
"styleRecalcs": 58,
"styleRecalcDurationMs": 14.422,
"layouts": 9,
"layoutDurationMs": 2.6020000000000003,
"taskDurationMs": 857.666,
"heapDeltaBytes": -9523440,
"heapUsedBytes": 96227564,
"domNodes": -190,
"jsHeapTotalBytes": 3837952,
"scriptDurationMs": 118.04400000000001,
"eventListeners": -174,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.665454545454548,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "subgraph-transition-enter",
"durationMs": 1435.2039999999988,
"styleRecalcs": 18,
"styleRecalcDurationMs": 25.567,
"layouts": 5,
"layoutDurationMs": 16.71,
"taskDurationMs": 1024.781,
"heapDeltaBytes": 35450260,
"heapUsedBytes": 135473104,
"domNodes": 15950,
"jsHeapTotalBytes": 16654336,
"scriptDurationMs": 30.268000000000004,
"eventListeners": 3244,
"totalBlockingTimeMs": 149,
"frameDurationMs": 19.594594594594593,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "viewport-pan-sweep",
"durationMs": 11238.549999999976,
"styleRecalcs": 250,
"styleRecalcDurationMs": 32.708,
"layouts": 8,
"layoutDurationMs": 2.4650000000000003,
"taskDurationMs": 6534.942,
"heapDeltaBytes": -14168568,
"heapUsedBytes": 89143432,
"domNodes": -296,
"jsHeapTotalBytes": 233472,
"scriptDurationMs": 2871.6600000000003,
"eventListeners": -128,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.740536512667664,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "viewport-pan-sweep",
"durationMs": 8939.414999999939,
"styleRecalcs": 250,
"styleRecalcDurationMs": 36.137,
"layouts": 8,
"layoutDurationMs": 3.6439999999999997,
"taskDurationMs": 6182.165,
"heapDeltaBytes": 1468240,
"heapUsedBytes": 103708812,
"domNodes": -296,
"jsHeapTotalBytes": -1212416,
"scriptDurationMs": 3069.918,
"eventListeners": -128,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.728464419475657,
"p95FrameDurationMs": 16.799999999999272
},
{
"name": "vue-large-graph-idle",
"durationMs": 23000.73199999997,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 22454.422,
"heapDeltaBytes": -58876076,
"heapUsedBytes": 269807484,
"domNodes": -3337,
"jsHeapTotalBytes": 14929920,
"scriptDurationMs": 326.07599999999996,
"eventListeners": -653,
"totalBlockingTimeMs": 0,
"frameDurationMs": 39.69343696027634,
"p95FrameDurationMs": 83.30000000000109
},
{
"name": "vue-large-graph-idle",
"durationMs": 22982.86799999994,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 22394.434999999998,
"heapDeltaBytes": -7156344,
"heapUsedBytes": 293005292,
"domNodes": -3337,
"jsHeapTotalBytes": 12832768,
"scriptDurationMs": 324.732,
"eventListeners": -653,
"totalBlockingTimeMs": 0,
"frameDurationMs": 40.07993019197208,
"p95FrameDurationMs": 83.30000000000291
},
{
"name": "vue-large-graph-pan",
"durationMs": 28245.960999999967,
"styleRecalcs": 180,
"styleRecalcDurationMs": 21.96600000000001,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 27937.985,
"heapDeltaBytes": -28900844,
"heapUsedBytes": 275761884,
"domNodes": -3337,
"jsHeapTotalBytes": 14405632,
"scriptDurationMs": 934.0060000000001,
"eventListeners": -651,
"totalBlockingTimeMs": 54,
"frameDurationMs": 52.86947565543072,
"p95FrameDurationMs": 116.59999999999854
},
{
"name": "vue-large-graph-pan",
"durationMs": 19667.877000000088,
"styleRecalcs": 151,
"styleRecalcDurationMs": 17.359999999999985,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 19381.718,
"heapDeltaBytes": -20515060,
"heapUsedBytes": 298517492,
"domNodes": -3337,
"jsHeapTotalBytes": 19648512,
"scriptDurationMs": 853.604,
"eventListeners": -651,
"totalBlockingTimeMs": 33,
"frameDurationMs": 36.62160148975792,
"p95FrameDurationMs": 66.70000000000073
},
{
"name": "vue-node-resize-workload",
"durationMs": 8386.010999999997,
"styleRecalcs": 20,
"styleRecalcDurationMs": 83.41099999999999,
"layouts": 20,
"layoutDurationMs": 31.575999999999993,
"taskDurationMs": 8253.685000000001,
"heapDeltaBytes": -41412648,
"heapUsedBytes": 278307776,
"domNodes": -3337,
"jsHeapTotalBytes": 3657728,
"scriptDurationMs": 128.53900000000002,
"eventListeners": -653,
"totalBlockingTimeMs": 0,
"frameDurationMs": 47.63068181818182,
"p95FrameDurationMs": 100
},
{
"name": "vue-node-resize-workload",
"durationMs": 6101.484000000028,
"styleRecalcs": 20,
"styleRecalcDurationMs": 67.24499999999998,
"layouts": 20,
"layoutDurationMs": 26.16700000000001,
"taskDurationMs": 5968.700999999999,
"heapDeltaBytes": -34441060,
"heapUsedBytes": 275178700,
"domNodes": -3337,
"jsHeapTotalBytes": 12570624,
"scriptDurationMs": 103.04500000000002,
"eventListeners": -653,
"totalBlockingTimeMs": 0,
"frameDurationMs": 33.88722222222221,
"p95FrameDurationMs": 66.70000000000073
},
{
"name": "vue-zoom-out-idle",
"durationMs": 11541.696000000002,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 11240.301,
"heapDeltaBytes": 14705776,
"heapUsedBytes": 285237096,
"domNodes": 0,
"jsHeapTotalBytes": 0,
"scriptDurationMs": 160.0999999999999,
"eventListeners": 0,
"totalBlockingTimeMs": 0,
"frameDurationMs": 39.76862068965518,
"p95FrameDurationMs": 83.30000000000291
},
{
"name": "vue-zoom-out-idle",
"durationMs": 11432.545000000006,
"styleRecalcs": 0,
"styleRecalcDurationMs": 0,
"layouts": 0,
"layoutDurationMs": 0,
"taskDurationMs": 11260.437000000002,
"heapDeltaBytes": 4384588,
"heapUsedBytes": 290554088,
"domNodes": 0,
"jsHeapTotalBytes": 0,
"scriptDurationMs": 158.587,
"eventListeners": 0,
"totalBlockingTimeMs": 0,
"frameDurationMs": 41.06546762589927,
"p95FrameDurationMs": 83.39999999999782
},
{
"name": "workflow-execution",
"durationMs": 446.98499999998376,
"styleRecalcs": 17,
"styleRecalcDurationMs": 11.555,
"layouts": 13,
"layoutDurationMs": 4.589,
"taskDurationMs": 126.86500000000001,
"heapDeltaBytes": -12591316,
"heapUsedBytes": 88752884,
"domNodes": 100,
"jsHeapTotalBytes": 4718592,
"scriptDurationMs": 13.393999999999998,
"eventListeners": 1,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.666666666666668,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "workflow-execution",
"durationMs": 111.77600000007715,
"styleRecalcs": 8,
"styleRecalcDurationMs": 9.684,
"layouts": 8,
"layoutDurationMs": 4.218,
"taskDurationMs": 88.28400000000002,
"heapDeltaBytes": 4799880,
"heapUsedBytes": 106323936,
"domNodes": 121,
"jsHeapTotalBytes": 262144,
"scriptDurationMs": 9.190999999999999,
"eventListeners": 1,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.657142857142844,
"p95FrameDurationMs": 16.700000000000273
},
{
"name": "agent-composer-empty-conversation-typing",
"durationMs": 527.0030000000361,
"styleRecalcs": 5,
"styleRecalcDurationMs": 0.642,
"layouts": 76,
"layoutDurationMs": 16.182,
"taskDurationMs": 480.89300000000003,
"heapDeltaBytes": -13958460,
"heapUsedBytes": 79414548,
"domNodes": 4,
"jsHeapTotalBytes": 1835008,
"scriptDurationMs": 234.33100000000002,
"eventListeners": 292,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.665624999999977,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "agent-composer-empty-conversation-typing",
"durationMs": 512.1519999999009,
"styleRecalcs": 5,
"styleRecalcDurationMs": 0.735,
"layouts": 76,
"layoutDurationMs": 15.563,
"taskDurationMs": 463.13400000000007,
"heapDeltaBytes": -14087724,
"heapUsedBytes": 78559224,
"domNodes": 4,
"jsHeapTotalBytes": 2883584,
"scriptDurationMs": 225.536,
"eventListeners": 292,
"totalBlockingTimeMs": 0,
"frameDurationMs": 16.667741935483896,
"p95FrameDurationMs": 16.700000000000728
},
{
"name": "agent-composer-long-conversation-typing",
"durationMs": 561.9340000000648,
"styleRecalcs": 5,
"styleRecalcDurationMs": 3.3400000000000003,
"layouts": 76,
"layoutDurationMs": 16.107,
"taskDurationMs": 527.895,
"heapDeltaBytes": 568332,
"heapUsedBytes": 117674192,
"domNodes": 4,
"jsHeapTotalBytes": 0,
"scriptDurationMs": 207.15499999999997,
"eventListeners": 292,
"totalBlockingTimeMs": 0,
"frameDurationMs": 17.15588235294118,
"p95FrameDurationMs": 16.800000000000182
},
{
"name": "agent-composer-long-conversation-typing",
"durationMs": 600.3149999999096,
"styleRecalcs": 5,
"styleRecalcDurationMs": 2.337,
"layouts": 76,
"layoutDurationMs": 15.793000000000001,
"taskDurationMs": 568.838,
"heapDeltaBytes": 1817284,
"heapUsedBytes": 120563552,
"domNodes": 4,
"jsHeapTotalBytes": 524288,
"scriptDurationMs": 229,
"eventListeners": 292,
"totalBlockingTimeMs": 0,
"frameDurationMs": 17.13055555555555,
"p95FrameDurationMs": 16.800000000000182
}
]
}🔬 E2E CoverageLine coverage: 63.9% Coverage totals
Top 10 files by uncovered lines
🎭 Playwright: ✅ 2945 passed, 0 failed · 2 flaky📊 Browser Reports
🎨 Storybook: ✅ Built — View Storybook🧩 Custom Nodes Ecosystem Matrix: 🟡 Withheld — could not measureExecutes the frontend JS of every registry pack that ships any, against this change, in both renderers. The eight
Findings and check detailsThe matrix runs on same-repository version-bump PRs with relevant changes, main-branch pushes, and manual dispatches. This candidate does not qualify, so every expensive stage was skipped. Reproduce locally# build one shard's fixture, then run it
python3 scripts/registry-census/build_matrix.py --shard 1/4
MATRIX_RENDERER=vue MATRIX_VUE=1 \
npx vitest run --config vitest.matrix.config.mts
Full docs: scripts/registry-census/README.md 🌾 Fallow: ✅ PassedFallow audits the diff for duplication, complexity and dead code. It gates on new findings only, so when the audit completes, a red is something this PR introduced or moved — never inherited backlog. A red can also mean the audit itself did not finish; the details below say which happened. Findings and check detailsNo new findings in the changed files. Reproduce locally# the base the gate compared against
npx fallow audit --root . --quiet --format json \
--changed-since f0e755155916e8ee988f20d787d26f34dca52334
Full docs: ADR-DEVEX-LINT-0015 🏛️ Architecture: ✅ PassedFindings and check detailsWarnings (100)
Reproduce locallypnpm architecture:checkFull docs: Frontend domain catalog |
Codecov Report❌ Patch coverage is
@@ Coverage Diff @@
## main #21154 +/- ##
==========================================
+ Coverage 86.65% 87.50% +0.84%
==========================================
Files 3775 2698 -1077
Lines 178512 149994 -28518
Branches 49352 39116 -10236
==========================================
- Hits 154685 131245 -23440
+ Misses 21760 18359 -3401
+ Partials 2067 390 -1677
Flags with carried forward coverage won't be shown. Click here to find out more.
... and 1093 files with indirect coverage changes 🚀 New features to boost your workflow:
|
This comment has been minimized.
This comment has been minimized.
There was a problem hiding this comment.
🔍 Cursor Review — Consolidated panel
Triggered by @christian-byrne.
Found 4 finding(s).
| Severity | Count |
|---|---|
| 🟡 Medium | 1 |
| 🟢 Low | 3 |
Panel: 6/6 reviewers contributed findings.
| async function doLoadMore() { | ||
| if (!morePages.value) return | ||
| const query = searchedQuery() | ||
| const searchMode = toValue(inputs.searchMode) |
There was a problem hiding this comment.
🟡 Medium — If the search mode or query changes while the first page is still loading, the search for the new inputs is never sent. The reload triggered by the change merges into the reload already running, and that reload captured the old mode here. The list then keeps showing old-mode results under the new filter until something else changes, and a later loadMore() reads the current mode and appends its pages to the stale first page. Checking firstPage.searchMode === searchMode.value in ManagerDialog.vue hides the tip but leaves the stale results. The new tests lock this in: useRegistrySearch.test.ts ('reports the mode a first page was searched in...') and ManagerDialog.test.ts ('hides the tip when a nodes-mode ... search lands after the switch to packs') pass only because no packs-mode search ever runs. Run the reload again, or replace the running one, when inputs change mid-load, and have the tests assert that a packs-mode request follows the switch. Raised by 3 of 6 reviewers (claude-opus-5-5-xhigh adversarial, claude-opus-5-5-xhigh edge-case, kimi-k3-high edge-case).
| export function toRepoName(query: string): string { | ||
| return stripRepoOwner(query.trim().replace(TRAILING_GIT_OR_SLASHES, '')) | ||
| return stripRepoOwner( | ||
| query.trim().replace(TRAILING_GIT_OR_SLASHES, '').trimEnd() |
There was a problem hiding this comment.
🟢 Low — The trailing cleanup runs only once: strip, then trimEnd(). Whitespace can therefore uncover a .git suffix or another slash that is never removed. 'ltdrdata/ComfyUI-Manager.git /' becomes 'ComfyUI-Manager.git', so isLegacyManagerQuery returns false. 'kijai/comfyui-kjnodes / /' keeps a trailing ' /', so the owner is never stripped. toComparableQuery (line 38) has the same gap. Matching a single pattern such as /(?:\.git)?[\s/]*$/ after trimming, or repeating the cleanup until nothing changes, would handle these the same way as the .git/ and ' /' cases the new tests cover. Raised by 5 of 6 reviewers (claude-opus-5-5-xhigh adversarial, kimi-k3-high adversarial, claude-opus-5-5-xhigh edge-case, gpt-5.6-sol-xhigh edge-case, kimi-k3-high edge-case).
| query: string, | ||
| params: SearchNodePacksParams | ||
| ): Promise<SearchPacksResult> => { | ||
| // Known limitation: analyticsTags are left out of the cache key, so a |
There was a problem hiding this comment.
🟢 Low — This new comment records a known analytics gap instead of fixing it, and the repo's AGENTS.md bans code comments of this kind. Because analyticsTags is left out of the cache key, a typed (user-tagged) search for a query already cached from an untagged deep link, or from switching modes back, sends no request and logs no analytics event, so user-search analytics are undercounted with no signal. Either preserve the event on cache hits when analyticsTags is present, or remove the comment and record the accepted limitation in the PR description or an issue. Raised by 4 of 6 reviewers (claude-opus-5-5-xhigh adversarial, claude-opus-5-5-xhigh edge-case, gpt-5.6-sol-xhigh edge-case, kimi-k3-high edge-case).
| } catch (err) { | ||
| console.error(err) | ||
| } catch (error) { | ||
| reportError(error, { |
There was a problem hiding this comment.
🟢 Low — Moving from console.error to reportError sends expected failures to the error sinks: being offline, an ad blocker blocking the search provider, or every provider being unavailable. During an outage each debounced keystroke or scroll page sends another error report, which can bury real failures. Consider filtering expected network failures, or reporting once per session or outage. Raised by 1 of 6 reviewers (claude-opus-5-5-xhigh adversarial).
A reload requested while the first page loads merges into the running reload, which had captured the old query and mode. The list kept the stale first page, and a later loadMore appended current-mode pages to it. Each page request now checks that the query and mode it searched still match the inputs when it settles. If they do not, the response (or error) is dropped, and a reload starts over with the current inputs. usePreemptableQueue is unchanged because useAssetsQuery also relies on it.
The repo bans code comments outside JSDoc on exported APIs. The note that cached pack searches log no analytics event moves to the PR description as a known limitation.
The trailing cleanup ran once, so whitespace could hide a .git suffix or another slash. 'ltdrdata/ComfyUI-Manager.git /' kept '.git' and no longer matched the legacy Manager, and 'kijai/comfyui-kjnodes / /' kept the owner. One regex now removes any run of them.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
Reviewed head: d6b7476a1ff5b098501db84785981875177c8c97
Reviewed base: e5a8fe732edb5ba56f24212716cf61a4b73d52bc
Claude review output
I reviewed PR #21154 and found 10 issues. None is a crash, and the stale-response retry loop in useRegistrySearch works when traced through usePreemptableQueue. Two findings I checked myself: the registry does have a comfyui-manager pack (from api.comfy.org), and the new regex slowdown reproduces. I didn't run the test suite because this checkout has no node_modules. Nothing has been posted to GitHub.
Worth raising with the author
- The tip on filtered tabs is effectively gone in Node Pack mode (
ManagerDialog.vue:510). The tip now checks the rawsearchResultsinstead of the tab'sdisplayPacks. The registry returns thecomfyui-managerpack for that search, so the condition is always true. On the Installed tab, the new pip-installed Manager isn't a custom_nodes pack, so the grid shows "No results found" and no tip. #21133 explicitly wanted the tip in that case. The PR description says this change is deliberate, so it's a design question, but the stated reasoning doesn't account for the pack always being in the results. The new test only passes because its mock controls what the registry returns. - A failed search looks like "no such pack" (
useRegistrySearch.ts:104). After a failure,itemsis[]andfirstPageis null, so the dialog says "No results found / Try a different search" when it should say the search failed. Suggestions from the previous query also stay visible. This conflicts withdocs/guidance/error-handling.md§1 and §5. - Error reports have no limit (
useRegistrySearch.ts:100).reportErrorfires at levelerroron every failed page fetch: each keystroke, mode switch and scroll page while offline or while a provider's circuit breaker is open. There's nodegradedtag, and the message wraps the gateway error ("All search providers failed. Last error: …"), so reports split by message.algoliaSearchProvideralready reports this kind of failure aswarning/degraded. - The retry waits for the outdated request to finish (
useRegistrySearch.ts:116). The loop doesn't use the queue's AbortSignal. A mode switch mid-load therefore waits for the stale request, plus its Algolia rewrite round trip, before sending the new search. The discarded request is still taggeduserin analytics. - The new regexes backtrack quadratically on long runs of whitespace (
searchQueryUtil.ts:9,11). Reproduced on a string ofa+ N spaces +b: 10k spaces took 88ms and 30k took 788ms, against 0ms for the old regex. Only a pathological paste triggers it, but anchoring on a non-whitespace character before the tail would avoid it.
Lower priority
- Test gap: no test covers a stale response on the
loadMorepath (page 2 or later), or the inputs changing twice during one reload. - Probably dead code:
firstPage.searchModeand its check in the component look unnecessary now that stale responses are dropped. No test fails if they're removed. - Root cause left in place: the do/while loop works around
usePreemptableQueue.preemptsilently merging a new reload into the running one.useAssetsQueryworks around the same behaviour a different way. Fixingpreemptwould remove both workarounds. - Misleading name:
PageLoadOutcomereturns'loaded'for skipped and failed loads.loadMorealso wrapsdoLoadMorein an extra lambda just to discard that value. - Silent drops: stale failures are discarded without any log, so failures while the user is still typing never show up anywhere.
My recommendation is to raise 1 through 3 on the PR. Item 1 needs a decision from the author, not just a code fix. Items 4 and 5 are reasonable to include, and 6 through 10 are optional cleanup.
Verification and scope
No explicit Blocking section was produced; the original classifications above are preserved. The test suite was not run because this isolated checkout has no node_modules.
The registry API confirms the comfyui-manager pack exists. Source inspection confirms the raw-results tip predicate and the failed-search empty state. Item 1 is a deliberate behavior change requiring an author decision; item 2 describes pre-existing UI behavior that the PR description explicitly retains. Item 3 overlaps the existing error-reporting discussion; reportError deduplicates identical Error instances, but the gateway constructs a new Error for each exhausted search request, without an outage-level limit here.
The regex slowdown was independently reproduced in Node on an internal whitespace run followed by a non-whitespace character: 10,000 spaces took approximately 84 ms and 30,000 took 759 ms. This is a pathological-input performance concern, not a demonstrated normal-use blocker.
The registry always returns the comfyui-manager pack for a ComfyUI-Manager search, so checking the raw search results kept the tip hidden on filtered tabs such as Installed, where the pip-installed Manager is not listed. The tip again checks the packs the current tab shows.
A failed registry pack search leaves the dialog usable, so it is reported at warning level with an outcome of degraded, as the Algolia provider already does for its failed rewrite searches.
A failed first-page search left an empty list, so the dialog said "No results found" and kept the previous query's suggestions. useRegistrySearch now exposes searchFailed and clears the suggestions when the first page fails, and the dialog shows the registry connection error for it. A failed opening listing no longer leaves the skeleton up.
doLoadMore returned 'loaded' even when it skipped or failed. It now returns 'current' or 'stale', which is the only thing the reload loop checks. The loadMore wrapper stays because the queue runner must return Promise<void>.
Stale responses are already dropped, so firstPage only lagged the inputs while a later page was still loading. useRegistrySearch now clears firstPage as soon as the query or mode changes, which lets the dialog drop its own search mode check and firstPage drop the searchMode field.
…near time The trailing-run regexes retried from every position of an inner run of whitespace, so a query with tens of thousands of spaces between two words took seconds. toRepoName and the rewrite comparison now walk back from the end of the query instead, with the same results.
One test lets a page-two response land after the mode changed and checks that its packs and suggestions are dropped before the new mode's first page loads. Another changes the query twice while the first page loads and checks that only the latest query's results are kept.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
Reviewed head: a6692bc5251d7d84bb6d006b6f20c557bbf9fdd1
Reviewed base: e5a8fe732edb5ba56f24212716cf61a4b73d52bc
Accepted live base: 4e84ca887192405d4619f0c105cd5d2d9edb09a9
Claude review output
I re-reviewed PR #21154 at its current head (a6692bc525). I'd approve it once the error-report flooding below is fixed or deliberately accepted. The rest of my notes are optional.
I traced the stale-response retry against usePreemptableQueue and found no bug. It handles inputs changing during the first page, during a later page, and twice during one load. CI is green on this exact commit: all 8 unit test shards, lint, typecheck and Playwright. I didn't run the tests locally because this checkout has no node_modules. I posted nothing to GitHub.
Earlier findings: all addressed
- The search for the new mode was never sent (Cursor, Medium): fixed by the retry loop. Tests cover the first page, a later page, a failed stale request and two changes in one load. Each test would fail against the old code.
- The tip disappeared on filtered tabs: the tip check is back to the packs the tab shows, the same as
main, with a test for the Installed tab. - A failed search said "No results found": it now shows the registry-error message and clears the suggestions. The opening listing no longer leaves the loading skeleton up.
- Slow regex on long whitespace runs: replaced with a linear scan from the end, with a 50,000-space test. Repeated tails like
/ /and.git /are stripped too. - Cleanup: the extra
firstPage.searchModeis gone andPageLoadOutcomeis nowPageFreshness. The analytics comment moved into the PR description. - Accepted, not fixed: an outdated request still isn't aborted, and the queue's merge behaviour is left alone. The description explains both.
Still open
-
Error reports have no limit (
useRegistrySearch.ts:101). The level is nowwarningwith anoutcome: degradedtag, but every failed page fetch still sends a report. While the user is offline, or after the gateway has given up on both providers, each query change (after the 320 ms typing pause) and each mode switch adds another report. Those later failures happen instantly, with no network call. The gateway creates a newErroreach time, soreportErrordoesn't treat them as duplicates.docs/guidance/error-handling.md§5 asks for exactly this case to be limited ("first N, or first per key"). Reporting only the first failure after a success would be enough. This was Cursor's last unaddressed finding. -
Optional: a failed later page just ends the list (
useRegistrySearch.ts:107). If page 2 or later fails, scrolling stops with no message, unlike the first-page failure the PR now shows. There's also no direct retry after a failure: retyping the same query within the typing pause leaves the query unchanged, so no new search is sent. Users have to change the query or mode, or reopen the dialog. This could be a follow-up. -
Nit:
// Empty state messages based on current tab and search state(ManagerDialog.vue:458) sits aboveemptyStateTitleandemptyStateMessage, which this PR changes. AGENTS.md says to delete existing comments in any function you modify.
The PR has no merge conflicts and doesn't overlap with anything merged to main since it branched. If you want, I can post this as a review comment on the PR.
Verification and scope
The original classifications are preserved. Claude recommends fixing or deliberately accepting the repeated reporting concern; no explicit Blocking section was produced. This is the remaining previously discussed reporting concern, not a newly discovered separate issue. Source inspection confirms each exhausted gateway search constructs a fresh Error, and the current catch reports each current-input failure without a per-outage limiter.
GitHub checks were independently verified green on the reviewed head. No local test suite was run because this isolated checkout has no node_modules. The base-only update #21263 changes publish-dialog tag chips and a screenshot; it does not overlap this PR or change the findings. Effective PR diff remains identical at both bases: 28,402 bytes, SHA-256 b442eee49b37b7271b1d39455b5c6bea53e84993af3c0d6f17192544af3bf43a.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
Reviewed head: dd79996f1ba65b311172519b654223b1d4da9f0e
Reviewed base: 4e84ca887192405d4619f0c105cd5d2d9edb09a9
Accepted live base: e7fc8af32cb77c88ae5a88ffe782c2b91287093e
Claude final verdict
I reviewed PR #21154 (head dd79996f) and reported 11 findings. I confirmed only the top one against the code; the other ten are marked plausible.
Main problem: the new "search failed" handling never runs in production. The Comfy Registry fallback turns every network error into an empty successful result, so the gateway never rejects. That happens in two places: comfyRegistryService.executeApiRequest returns null on error, and useCachedRequest caches that null. So when the user is offline, the dialog still shows "No results found" and can still show the legacy-manager tip. The PR's tests pass only because they mock the gateway to reject, which the real gateway can't do.
To actually fix the user-facing bug, the registry provider needs to report failure instead of returning an empty list.
Most of the rest are smaller state and timing issues around the new failure state. One other notable claim: a commit says pack-query normalization is now linear time, but the toRepoName pattern can still slow down sharply on a long pasted slug.
Full findings retained from Claude
Per the final verdict, only finding 1 is confirmed; findings 2–11 remain plausible candidates, not verified defects. Their original wording follows.
[
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 112,
"summary": "In production this catch branch never runs: the gateway's last provider (ComfyRegistry) turns every failure into an empty successful result, so `searchPacks` does not reject. `searchFailed`, the cleared suggestions and `reportError` only happen in tests that mock the gateway to reject.",
"failure_scenario": "Go offline and type `gguf`. Algolia throws, and `registrySearchGateway` falls back to `useComfyRegistrySearchProvider`. There, `executeApiRequest` catches the axios error and returns null, `useCachedRequest` caches the null, and the provider returns `{ nodePacks: [], querySuggestions: [] }`. `doLoadMore` takes the success path: `firstPage = { rawResultsEmpty: true }`, `searchFailed` stays false and nothing is reported. The dialog still says \"No results found matching your search.\", which is the 'Before' behavior the PR says it fixes. A `comfyui-manager` search offline also shows the legacy-manager tip. Each test only passes because it mocks `useRegistrySearchGateway().searchPacks` to reject, which the real gateway cannot do. This is the placeholder-on-failure pattern that docs/guidance/error-handling.md §1 forbids, and it sits one layer below this fix."
},
{
"file": "src/workbench/extensions/manager/components/manager/ManagerDialog.vue",
"line": 408,
"summary": "`isInitialLoad` still checks `searchResults.length === 0 && searchQuery === ''` instead of whether the first page has settled. An opening listing that succeeds with zero packs (which is what a failed registry fallback returns) keeps the skeleton up forever.",
"failure_scenario": "Open the Manager on the All tab while the registry is unreachable. The listing resolves to `[]` with `searchFailed` false, so `isInitialLoad` is true, `isLoading` is true and `GridSkeleton` never goes away. The PR says it fixes 'the loading skeleton stayed up', but that fix only covers a rejected promise. The fix would be to key this on `packs.firstPage.value === null` (or settled state) together with `isSearchFailed`."
},
{
"file": "src/workbench/extensions/manager/components/manager/ManagerDialog.vue",
"line": 472,
"summary": "The failed first-page state says 'Please try again later', but nothing reruns the search. The `NoResultsPlaceholder` already supports `buttonLabel`/`@action`, which could call `packs.loadNew()`, but it is not used.",
"failure_scenario": "A search for `gguf` fails and the error placeholder appears. The user retypes `gguf` (the debounced value doesn't change), or switches tabs and back. The watcher does not fire, so no request is sent and the error stays until the query or mode changes or the dialog is reopened. The PR lists 'no direct retry' as a limitation only for later pages, but it applies to the first page too."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 92,
"summary": "The `try` covers the state updates after the await as well as the untrusted `searchPacks` call. A throw after `firstPage` is assigned leaves `firstPage` set and `searchFailed` true at the same time, and the throw is reported as a registry search failure.",
"failure_scenario": "Say page 0 resolves and `firstPage.value = {...}` runs. Then `items.value.push(...nodePacks)` throws, for example a RangeError on a very large spread or a malformed provider result. The catch sees `isCurrent()`, calls `reportError` with `error_searching_registry_packs`, and sets `searchFailed = true` and `suggestions = []`, but `firstPage` stays non-null. ManagerDialog then shows the 'Error connecting' state while `isUnmatchedLegacyManagerSearch` can still show the tip. error-handling.md §2 says to wrap only the untrusted call."
},
{
"file": "src/workbench/extensions/manager/components/manager/ManagerDialog.vue",
"line": 405,
"summary": "`isSearchFailed` does not record which query or mode failed. It also uses the non-debounced `isSearchBacked`, so an earlier failure is shown against a new query, including a failure from a listing the user never saw.",
"failure_scenario": "Open the dialog on the All Installed tab with an empty query. The hidden `''` listing search fails, so `searchFailed` is true, but the tab isn't search-backed and shows nothing wrong. The user types `g`. `isSearchBacked` flips to true immediately, while the debounced search hasn't started yet, so for 320ms the placeholder says 'Error connecting to the Comfy Node Registry.' for a query that was never sent. The tip avoids this by comparing `firstPage.query` with `searchQuery.trim()`; the failure state has no equivalent check."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 145,
"summary": "On an input change the watcher clears `firstPage` but not `items`. When a later page is in flight, the reload waits for it, so the grid keeps showing the previous mode's packs under the new filter until that request settles.",
"failure_scenario": "In Nodes mode, scroll so that page 2 is loading, then switch to Node Pack mode. `preempt` waits on the active loadMore. `items` still holds the Nodes-mode page 1, `isSearchLoading` is true and the results are non-empty, so `isLoading` is false and the grid shows Nodes-mode packs labelled as Node Pack results for the whole page-2 round trip. This contradicts the PR's statement that 'the grid and the tip show only results for what is selected now'."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 53,
"summary": "`failureReportedSinceSuccess` is per instance and is reset only by a current success. Reopening the dialog sends a new report, and a recovered-but-stale success does not re-arm reporting. Both contradict 'one report until a search succeeds again'.",
"failure_scenario": "Offline: open the dialog (1 report), close it, open it again (a new `useRegistrySearch` instance, so a 2nd report), and so on for every open. In the other direction: after a reported failure, the network recovers and request `a` succeeds but is stale because the user already typed `ab`, so the flag stays true. If `ab` then fails, nothing is reported even though a search succeeded in between."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 124,
"summary": "This works around the root cause rather than fixing it. `usePreemptableQueue.preempt` silently merges a second preempt into the one already running. The PR compensates with three consumer-side patches: a do/while staleness loop, an `isCurrent` closure in every request, and a `firstPage` reset in the watcher.",
"failure_scenario": "Any other `preempt` consumer (for example `useAssetsQuery`) whose inputs change during a reload has the same lost-rerun bug. The new search can't be sent until the stale request settles, and analytics count the stale request. The general fix is for `preempt` to schedule one follow-up run when called while a preempt is running, or to abort through the `controller.signal` it already passes to runners."
},
{
"file": "src/utils/searchQueryUtil.ts",
"line": 42,
"summary": "The commit claims 'linear time' for pack-query normalization, but `toRepoName` still runs `BARE_COMPOUND_REPO_SLUG`. Its two `[\\w.-]*` runs around `[A-Za-z0-9][-_][A-Za-z0-9]` backtrack quadratically.",
"failure_scenario": "`toRepoName('a/' + 'a-a'.repeat(16667) + '!')` (about 50k chars) takes about 390ms in Node (76ms at 24k), roughly 4x per doubling. It runs inside the `isUnmatchedLegacyManagerSearch` computed (via `isLegacyManagerQuery(firstPage.query)`) and in `buildPackSearchFallbacks` on each Algolia miss, so a pasted long slug blocks the UI thread. The new 50,000-space test only covers the trailing-strip path."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 58,
"summary": "`firstPage`, `searchFailed` and the suggestions reset together describe one first-page state (loading / failed / loaded) split across separate refs, and the reload loop resets five variables in order.",
"failure_scenario": "docs/guidance/state-and-effects.md §1: \"if ending the workflow means resetting four variables in the right order, it was one state and you gave it four variables\". Today `firstPage !== null && searchFailed === true` can happen (see the try-scope finding), and the watcher has to reset `firstPage` separately from the loop. A `{ status: 'loading' } | { status: 'failed' } | { status: 'loaded'; query; rawResultsEmpty }` union would make the invalid combination impossible and remove the duplicate reset."
},
{
"file": "src/utils/searchQueryUtil.ts",
"line": 22,
"summary": "`stripTrailingRun` hand-rolls stripping of trailing characters. es-toolkit's `trimEnd(str, chars)` already strips a trailing run of given characters in linear time, which covers the `stripGit: false` path; only the `.git` suffix needs custom code.",
"failure_scenario": "AGENTS.md: \"Use es-toolkit for utility functions\" (and src/AGENTS.md: \"Use `es-toolkit` for utility functions\"). The bespoke loop with its options object and `endsWithGitSuffix` helper is more code to maintain than `trimEnd` plus a small `.git` loop."
}
]Verification and scope
No explicit Blocking section was produced; classifications and confidence are preserved. Source inspection independently confirms finding 1 for ordinary registry/network failures: comfyRegistryService.executeApiRequest returns null, useCachedRequest caches null (and also returns null on a rejected request), registrySearchProvider converts the null to nodePacks: [], and registrySearchGateway treats that as a success. This bypasses the new catch-based failed-search state for this scenario. No browser/offline reproduction was run; this is a verified source trace. The other ten candidates have not been independently established and should not be treated as a request to fix all of them.
GitHub checks were independently verified green on the reviewed head. No local test pass is claimed. The base-only update #21251 changes the usage-charge tooltip, tests, snapshots and locale copy; it has no overlapping files or effect on these findings. Effective PR diff remains identical at both bases: 30,481 bytes, SHA-256 daca8d4e0fa9a10233f5d289a5d69d3ca5c6a07b42ae003f1ae6842c9d7dd6a1.
The registry service returns null on a network or HTTP error and the cached request stores that null, so the registry provider turned every failure into an empty result and the gateway never rejected. The provider now rejects on a null response and clears that request cache, so the gateway fails over or rejects and the dialog shows the failure.
The bare owner/repo pattern wrapped the compound word join in two unbounded runs, so a long slug that failed to match backtracked quadratically. Match the slug shape first and test for the join separately.
firstPage and searchFailed described one loading, failed or loaded state across two refs, so a throw after the first page was stored could leave both set. A single status union makes that impossible and keeps the searched query on the failed state too.
When a later page was loading, the reload for new inputs waited for it, and the grid kept showing the previous mode's packs under the new filter until that request settled.
…uccess A success that arrived after the query changed did not re-arm failure reporting, so a failure right after the registry recovered went unreported.
The skeleton showed while the empty-query listing had no packs, so a listing that succeeded with zero packs kept it up forever. Key it on whether the first page is still loading instead.
The failed state did not record which query failed, so a hidden listing failure on an installed tab showed as an error for a typed query that had not been sent yet.
The failed state said to try again later, but retyping the same query sends no new search. A Retry button on the existing placeholder reruns the search for the current inputs.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
Reviewed head: 98ba15364cc1737cedcccee2dedf2529388ff526
Reviewed base: e7fc8af32cb77c88ae5a88ffe782c2b91287093e
Claude review output
I reviewed PR #21154, "fix: close four legacy-manager tip and pack search edge cases", at head 98ba153. It changes 10 files (+799/−76). The review found 15 issues. I re-read the code for the top four myself and they hold. The two most serious come from the registry provider now throwing when the registry returns null, so the gateway's existing circuit-breaker and retry logic starts applying to it for the first time.
Correctness
-
The registry fallback can lock itself out while the user keeps searching (
registrySearchProvider.ts:16, cause is inregistrySearchGateway.ts). Once the registry has failed 3 times, its circuit opens. From then on every search ends with "No available search providers" inside the gateway'stry. Thecatchthen callsrecordFailureonproviders[activeProviderIndex], which is the registry, and that resets the registry'slastAttemptto now. The 60 s wait never runs out as long as the user keeps typing or clicking Retry. So someone who can't reach Algolia, or whose Algolia provider failed to start, sees "Error connecting" and no request is sent until they stop for a minute. Before this PR the registry provider never threw, so this path couldn't happen. -
Each failed search sends the same registry request twice (
registrySearchProvider.ts:15). After Algolia has failed once,activeProviderIndexstays on the registry, becauseupdateActiveProviderOnFailurenever moves past the last provider. The second attempt in the loop tries the registry again.requireResponsejust cleared the cache, so that attempt goes back to the network instead of reading the cachednull. That doubles the round-trips and makes the circuit in #1 open after about 1.5 searches instead of 3. -
Typing only spaces shows the error on the Installed tab (
ManagerDialog.vue:412).isSearchBackedchecks the rawsearchQuery !== '', butisSearchFailedcompares the trimmed query. Offline, if you type a single space on the Installed tab, the failure of the hidden''listing replaces the installed packs with "Error connecting" and a Retry button. The PR is meant to stop exactly that case. -
After a failure, each keystroke briefly shows "No results found" (
ManagerDialog.vue:464). During the 320 ms debounce,firstPagestill holds the old failed query, soisSearchFailedis false and nothing is loading. While offline, the empty state flips between error, "No results found", skeleton and error on every edit. -
The real cause of the failure is thrown away (
registrySearchProvider.ts:16).executeApiRequesthas already recorded the HTTP status or axios message inregistryService.error. The newerror_searching_registry_packsreport only says "Comfy Registry request failed", so every report looks the same. -
A search can still be sent after the dialog closes (
useRegistrySearch.ts:131). If the debounce timer fires after unmount while a request is in flight, the reply is marked stale and the do-while loop sends a newsearchPacks. Any error from it is reported after the dialog is gone. -
A cancelled request would count as a registry failure (
registrySearchProvider.ts:14, not reachable yet).executeApiRequestalso returnsnullfor a cancelled request, so a futurecancelRequests()would trip the circuit breaker and show the error state.
Design
-
The stale-reply loop works around the queue in one consumer (
useRegistrySearch.ts:124).preemptmerges into the running task, anddoLoadMoreignores theAbortSignalthe queue already passes in. Fixing either at the queue level would remove the do-while loop and the duplicatedfirstPage/itemsreset, and would cut the discarded requests the PR lists as a known limitation. -
cache.clear()throws away every good cached page after one bad request (registrySearchProvider.ts:15). The root cause is thatuseCachedRequestcachesnull. Removing just that one entry would be enough. -
isFirstPageLoadingnever changes the result (ManagerDialog.vue:415). WheneverfirstPageis'loading', theisSearchLoadingbranch has already returned true. -
RegistrySearchRequestErrorhas no effect (registrySearchProvider.ts:8). It is never exported or checked withinstanceof, and the gateway re-wraps every provider error anyway.
Repo conventions
searchPackswas modified but kept its five existing//comments. AGENTS.md says to delete existing comments in any function you change.- The new
useRegistrySearch.integration.test.ts:11usesvi.mock<unknown>(...).vitest.mdallows that only for old partial mocks; new mocks should be typed. - Turning the service's
nullback into a throw that is caught two frames up conflicts with "expected failure is a return value" insrc/AGENTS.mdanderror-handling.md.
Tests
- The
searchQueryUtil.test.ts:109test titled "in linear time" has no time limit, so a quadratic regex that finishes under Vitest's 5 s timeout still passes.
I'd fix #1–#3 before merging. #1 and #2 can be fixed in the gateway (record the failure only against a provider that was actually tried, and skip repeating the same provider) or by not throwing from the provider. Nothing has been posted to the PR. If you want inline comments, rerun the review with --comment.
Independent verification
The original classifications are preserved. Claude recommends fixing findings 1–3 before merging, but did not produce an explicit Blocking section; all output remains in these details.
Findings 1 and 2 were reproduced with a focused Node harness executing the actual reviewed registrySearchGateway.ts and registrySearchProvider.ts after removing imports and stripping types. Only provider/store responses and the clock were controlled; no browser or live network test was run. With both providers failing, the first search made one registry call and the next search made two more registry calls. With Algolia unable to initialize, three registry failures opened its circuit; after simulated recovery, searches at 30, 60, 90 and 120 seconds made no additional registry call, but each renewed the cooldown. A call at 181.001 seconds (61.001 seconds after the last retry) finally reached the recovered registry. This verifies repeated Retry can postpone recovery and that one search can duplicate a fallback request.
Source inspection also confirms finding 3: isSearchBacked checks the raw non-empty query while the failed-query comparison trims it, allowing a spaces-only query to match a hidden empty-listing failure. The remaining findings retain Claude's wording and priority; they are not all independently reproduced. GitHub checks were verified green on this exact head. Verification here was the focused gateway harness and source inspection, not a full local test-suite run.
The search gateway now tries each provider at most once per search and records a failure only against a provider it actually called, so a search made while every circuit is open no longer restarts the registry's cooldown, and a failing search no longer asks the registry twice. The registry provider evicts only the failed request from its cache (new useCachedRequest.evict) and includes the registry service's error in the rejection, so reports can be told apart. useRegistrySearch stops rerunning a stale search, and skips reporting its failure, once its scope is disposed. ManagerDialog checks the trimmed query when deciding whether the view is search-backed, so a query of only spaces on the Installed tab no longer shows a failed hidden listing, and it shows the loading skeleton instead of "No results found" while an edited query waits to be searched. Tests: a time limit on the linear-time slug test, and a typed axios adapter in the registry search integration test.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
Reviewed head: 1de2664ad2ff856fef81c61ee2aea21c64d2237f
Reviewed base: 592d64c685f58538579b076e445c0a4de24370db
Claude final verdict
I'd request changes on PR #21154 because of one regression the PR doesn't mention: a spaces-only query on a filtered tab. Most of the other behaviour findings are already listed under "Known limitations" in the PR description.
The review pass came back with 15 findings. I checked the ones below marked (checked) against the code at 1de2664. The rest come from that pass and I didn't re-check them. Nothing was run, and nothing has been posted to GitHub.
Bugs the PR doesn't mention
- (checked) A spaces-only query on the Installed, Update, Conflicting, Workflow or Missing tabs breaks.
isSearchBackednow uses the trimmed query (ManagerDialog.vue:374). ButuseManagerDisplayPacksstill gets the rawsearchQuery(line 433), so" "counts as a search there. The tab then shows the installed packs that happen to be on the first page of the empty-query listing, can't load more, and often says "No results found". Before the PR both sides agreed. This came from the PR's own "spaces only" follow-up, and its test (ManagerDialog.test.ts:516) only checks that the error text is absent. Fix: passtrimmedSearchQuerytouseManagerDisplayPacks. - (checked) The stale check compares values instead of a request counter (
useRegistrySearch.ts:90). Page 2 ofggufis loading, the query becomesggufx, then goes back togguf. The second reload merges into the first, so when page 2 lands it counts as current. It gets pushed into the cleared list, and the grid shows page 2 with no page 1 until the reload replaces it. If page 2 fails instead, it sends a report for a result that gets thrown away. A request counter would close this. - (checked) Results from the two providers can now get mixed in one list (
registrySearchGateway.ts:110). Now that the registry can fail,findUntriedProvidercan fall back from it to Algolia: page 0 comes from the registry and page 1 from Algolia, which ranks differently. That gives duplicates and gaps, and duplicateitem.idkeys in the grid. Mixing the other way (Algolia first, then the registry) already happened before this PR. - (checked) Hidden listing failures still go to telemetry. When the dialog opens offline on Installed, Workflow or Missing, the empty-query listing fails and gets reported as a warning. The UI correctly hides that error, but
reportFirstFailureSinceSuccessdoesn't check which tab is showing.
Listed as known limitations, but worth pushing on
- (checked) Retry can't get past the circuit breaker. After three failures each for Algolia and the registry, Retry fails instantly with no request for up to 60s, even once the network is back. The PR lists this, but its new Retry button is what makes it visible. An explicit Retry should probably reset the circuits, or skip the breaker.
- The error message reads the store's shared
registryStore.error(registrySearchProvider.ts:29). Another request, such asgetPacksByIdson the Installed tab, can overwrite it, so the report may name the wrong error. - A stale request isn't cancelled.
doLoadMoreand the reload ignore the queue'sAbortSignal, so a search for new input waits for the whole stale failover chain to finish. The value-comparison and rerun workaround behind item 2 exists becauseusePreemptableQueue.preemptmerges into the running request; fixing that once in the shared queue would helpuseAssetsQuerytoo.
Repo rules and cleanup
- (checked)
RegistrySearchRequestErroris an emptyErrorsubclass. The PR body says it exists to get pastcomfy/no-new-error-throw.docs/guidance/error-handling.mdsays the guidance covers custom subclasses too, so this works around the lint rule instead of following it. - Comments left in modified functions. The PR changes
useRegistrySearchGateway, which still has// Initialize providers…,// TODO: Add an "offline" provider…and// Check if enough time has passed…, plus long JSDoc on internal closures. The JSDoc onuseRegistrySearch(lines 31–36) is also longer than the one-to-two-line contract AGENTS.md allows. - The Installed-tab tip test proves less than it claims (
ManagerDialog.test.ts:360). It passes only because the mockedfilterInstalledPackalways returns[], so it can't show that the Installed tab hides the ComfyUI-Manager pack. - The provider evicts failures after the fact instead of
useCachedRequestnot caching them. Every other caller still caches a transient failure asnull. An option likecacheFailures: falsewould fix this in one place. - The first-page reset is written in three places: the watcher, the top of
reload's loop, andloadNew/invalidatethroughreload. The watcher's copy already skipspageNumberandmorePages. isUnmatchedLegacyManagerSearch(line 531) repeats the query check thatisFirstPageForInputalready does.stripTrailingRunre-implements es-toolkit'strimEnd(str, chars[]), andCachedRegistryRequestre-declares part ofuseCachedRequest's return type.Pick<ReturnType<…>, 'call' | 'evict'>would keep the two in sync.
I'd treat items 1–4 as blocking. Item 5 deserves a reply in the thread even though the PR lists it, because the new Retry button makes the lockout visible to users. If you want, I can post these as inline review comments on the PR.
Full findings retained from Claude
The following is the original detailed review pass. The final verdict above identifies which claims Claude checked; the pass itself was based on source inspection.
[
{
"file": "src/workbench/extensions/manager/components/manager/ManagerDialog.vue",
"line": 500,
"summary": "The new Retry button cannot get past the gateway's circuit breaker: once the registry provider can fail, three failed searches open both circuits, and Retry then fails at once without sending a request for up to 60s.",
"failure_scenario": "Go offline and open the dialog: the opening listing fails, which records one Algolia failure and one registry failure. Type a query (second failure each) and click Retry (third each), so both circuits are open. Come back online and click Retry: findUntriedProvider returns undefined, searchPacks throws 'No available search providers' with no network call, and the dialog shows 'Error connecting...' again for a full minute. Before this PR the registry never rejected, so its circuit never opened."
},
{
"file": "src/workbench/extensions/manager/components/manager/ManagerDialog.vue",
"line": 374,
"summary": "isSearchBacked now uses the trimmed query, but useManagerDisplayPacks still gets the raw searchQuery (line 433) and treats a spaces-only query as a search, so the two disagree about whether a search is active.",
"failure_scenario": "On the Installed tab, type a single space. useManagerDisplayPacks sees hasSearch=true and shows filterInstalledPack(first page of the '' listing), while isSearchBacked=false turns off canLoadMorePacks and the loading state. The tab shows only the installed packs that happen to be on the first listing page, cannot paginate, and often reads 'No results found / Try a different search' instead of the installed list. Before the PR both sides used the untrimmed query and stayed consistent. The new test at ManagerDialog.test.ts:516 only checks that the error text is absent."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 90,
"summary": "The stale check compares query and mode values rather than a generation counter, so a later-page request whose inputs changed and then changed back is treated as current and appended after the watcher has already cleared the items.",
"failure_scenario": "Page 2 of 'gguf' is in flight. The debounced query becomes 'ggufx' (watcher clears items, reload waits on the active loadMore), then 'gguf' again (reload merges). Page 2 lands, isCurrent() returns true, and items becomes [page-2 packs only] with pageNumber=2 while firstPage is 'loading'. The grid shows page 2 without page 1 until the reload replaces it. If page 2 fails instead, the failure is reported and morePages is set to false for a request whose result is thrown away."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 110,
"summary": "findUntriedProvider now wraps from a failed registry back to Algolia, and the registry can now fail, so one paginated result list can mix pages from two differently ranked indexes.",
"failure_scenario": "A transient Algolia failure moves activeProviderIndex to the registry, which serves page 0. On loadMore the registry fails, the gateway falls back to Algolia's page 1, and that page is appended to the registry's page 0. The list gets duplicates and gaps, and duplicate `item.id` keys in VirtualGrid's resultsWithKeys. Before the PR the registry resolved empty and the list simply ended."
},
{
"file": "src/services/providers/registrySearchProvider.ts",
"line": 29,
"summary": "The rejection message reads registryStore.error, which is shared by every request through the store's one registryService instance (including getPacksByIds), so the report can name another request's error or fall back to the generic message.",
"failure_scenario": "On the Installed tab offline, getPacksByIds and a search fail close together. executeApiRequest resets or overwrites the shared `error` ref, so the search failure is reported as 'Comfy Registry request failed: Failed to list packs: ...' or with no cause at all. Telemetry then blames the wrong endpoint."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 117,
"summary": "A failed opening listing is reported to telemetry even when the selected tab never shows it; the dialog hides that error in the UI (isSearchBacked) but the report path does not check this.",
"failure_scenario": "Open the dialog offline on the Installed, Workflow or Missing tab. useRegistrySearch still runs the '' listing, it fails, and reportError sends an 'error_searching_registry_packs' warning, while the UI correctly shows nothing. Every dialog open offline adds a warning for a failure no user saw."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 134,
"summary": "When the inputs change, the search for the new inputs is only sent after the outdated request settles: doLoadMore and the reload runner ignore the queue's AbortSignal, so the stale request is always awaited in full.",
"failure_scenario": "Offline or on a slow network, the opening listing goes through Algolia's host-retry timeouts and then the registry. If the user types a query meanwhile, that query's request waits for the whole stale failover chain to finish, so the skeleton stays up for seconds longer than needed. Racing the await against the preempt signal would let the new request go out right away."
},
{
"file": "src/workbench/extensions/manager/components/manager/ManagerDialog.test.ts",
"line": 360,
"summary": "The new Installed-tab tip test passes only because the mocked filterInstalledPack (line 52) always returns [], so it does not test the stated claim that the Installed tab hides the ComfyUI-Manager pack.",
"failure_scenario": "If the real filter showed comfyui-manager on the Installed tab (for example, Manager installed under custom_nodes), the tip logic would behave differently, but this test would stay green because the mock drops every pack regardless of install state."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 128,
"summary": "The do/while rerun, the watcher's early reset and the isCurrent closure work around usePreemptableQueue.preempt returning the running preempt's promise instead of scheduling a newer run; the shared queue is left unchanged.",
"failure_scenario": "Making preempt keep only the latest request while one is running (or cancel the active runner through its signal) would fix the merge for useAssetsQuery too. Instead each consumer has to re-implement stale detection, and this one does so by comparing values (see the ABA issue above)."
},
{
"file": "src/services/providers/registrySearchProvider.ts",
"line": 28,
"summary": "The provider undoes useCachedRequest's practice of caching failures (`cache.set(cacheKey, null)` on error, and caching null results) by evicting after the fact, instead of not caching failures in the first place.",
"failure_scenario": "Every other useCachedRequest consumer (getPackById, getNodeDefs, inferPackFromNodeName) still caches a transient failure for the life of the cache. The same failure-as-null is also why the provider has to read the racy shared `error` ref. An option such as `cacheFailures: false`, or a typed failure result from the service, would fix it once."
},
{
"file": "src/services/providers/registrySearchProvider.ts",
"line": 8,
"summary": "RegistrySearchRequestError is an empty Error subclass added only to get past comfy/no-new-error-throw, which breaks the repo rule against circumventing quality checks.",
"failure_scenario": "AGENTS.md says 'NEVER circumvent quality checks'. docs/guidance/error-handling.md says 'The rule matches only that literal form. The guidance applies to every `throw`, including `TypeError`, custom subclasses, and re-throws.' The PR body admits the class 'exists because the repo's lint rule rejects throwing a bare Error'."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 55,
"summary": "The PR modifies useRegistrySearchGateway (findUntriedProvider and searchPacks) but leaves comments in it: `// Initialize providers in priority order`, `// TODO: Add an \"offline\" provider...`, `// Check if enough time has passed to retry`, and narrative JSDoc on internal closures.",
"failure_scenario": "AGENTS.md says 'Delete the existing comments in any function you modify.' and 'Rationale, history, ticket links, workarounds, TODOs, and \"why\" belong in the commit message... They never go in a code comment.' The 4-line rationale JSDoc on the modified useRegistrySearch (lines 31-36) also breaks 'It states the contract in one or two lines... does not... give a history or rationale'."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 152,
"summary": "The watcher's reset of firstPage and items duplicates the reset at the top of reload's loop, so the first-page reset is written in three places.",
"failure_scenario": "Resetting firstPage and items once inside `reload` before calling `preempt(...)` would cover the watcher, loadNew (Retry) and invalidate, with no copy in the watcher. As written, the two resets can drift apart, which is how pageNumber and morePages got left out of the watcher's copy."
},
{
"file": "src/workbench/extensions/manager/components/manager/ManagerDialog.vue",
"line": 531,
"summary": "isUnmatchedLegacyManagerSearch repeats the `firstPage.query === trimmedSearchQuery.value` check that the new isFirstPageForInput computed already does.",
"failure_scenario": "`isFirstPageForInput.value && firstPage.status === 'loaded'` says the same thing. Keeping two copies of the 'first page is for the query on screen' rule means a later change to one can make the tip and the error or skeleton disagree."
},
{
"file": "src/utils/searchQueryUtil.ts",
"line": 23,
"summary": "stripTrailingRun hand-writes trailing-character trimming that es-toolkit's `trimEnd(str, chars[])` already provides (used in src/scripts/api.ts), and CachedRegistryRequest re-declares part of useCachedRequest's return type.",
"failure_scenario": "AGENTS.md says 'Use es-toolkit for utility functions'. toComparableQuery (stripGit: false) could be `trimEnd(input, [...])` with only the `.git` loop kept custom. `Pick<ReturnType<typeof useCachedRequest<TParams, TResult>>, 'call' | 'evict'>` would keep the provider's interface in sync with the composable."
}
]Independent verification and scope
Claude explicitly calls final-verdict findings 1–4 blocking; that classification is retained verbatim above. It did not produce the explicit Blocking section required for excerpts outside details, so all reviewer content stays collapsed. Not every listed issue is independently demonstrated or a request to fix every optional note.
Final-verdict finding 1 was reproduced by executing the actual useManagerDisplayPacks code with controlled store inputs and computed/getter substitutes: an empty query returned two installed packs, the raw spaces-only query returned none when those packs were absent from the listing page, and passing the trimmed query restored both. Source inspection confirms ManagerDialog passes the raw query to that composable while its isSearchBacked predicate uses the trimmed query. This verifies a filtered-tab inconsistency; no browser rendering test was run.
Final-verdict finding 3 was reproduced against the actual gateway and registry-provider source with controlled store/provider responses: a transient Algolia failure made the registry serve page 0 [registry-only, shared]; a later registry failure made Algolia serve page 1 [shared, algolia-only]. Appending these pages produced a duplicate shared id. This demonstrates provider switching can mix differently ranked page sets; it does not assert a specific live registry result ordering.
The two previously reproduced gateway regressions are fixed on this head: the focused harness observes one registry attempt per search, and retries during the open circuit do not renew its cooldown. A recovered registry is reached 61.001 seconds after its last actual failure despite intermediate retries.
The transient paging claim and hidden-listing warning concern retain Claude's classification, but their merge-blocking impact was not independently established here. A warning for a hidden request is also an observability policy decision, rather than proof of a user-visible failure. Documented limitations remain identified in Claude's output. GitHub checks were independently verified green on this head. Verification used focused Node harnesses and source inspection, not a full local test-suite or browser run.
…ges out Address the fifth review round on the pack search follow-up. - A spaces-only query on the Installed, Update, Conflicting, Workflow or Missing tab was treated as a search by useManagerDisplayPacks while the dialog treated it as no search, so the tab showed a partial page and "No results found". The dialog now passes the trimmed query to useManagerDisplayPacks and to the empty-state title and message. - useRegistrySearch dropped stale responses by comparing the query and mode, so a later page for "gguf" that landed after the query went to "ggufx" and back counted as current. Every reload now bumps a request generation, a response for an older generation is dropped without touching the list or reporting, and the first-page reset lives in reload alone. - Now that the registry provider can fail, the gateway could serve page 0 from one provider and page 1 from the other, which rank differently. Later pages of a list now go only to the provider that served its first page and fail if it fails, so a list never mixes two rankings. - A failed opening listing on a tab that does not show it was still reported. useRegistrySearch takes an isVisible input, and the dialog passes whether the active tab is search-backed. - Retry could not get past an open circuit. The gateway gains resetCircuits(), which loadNew (the Retry button) calls before reloading. - Search providers and the gateway now resolve to a SearchPacksOutcome instead of rejecting, per docs/guidance/error-handling.md. This removes RegistrySearchRequestError and the gateway's last throw, along with its lint suppression entry. - Remove the comments left in the gateway, shorten the useRegistrySearch JSDoc, reuse isFirstPageForInput for the legacy-manager tip, and make the Installed-tab tip test filter installed packs for real.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
Reviewed head: 47f108c5089be5d8fd4b52f2ca4ae6a24f232a40
Reviewed base: d9d1c643cad037d04288ccd7c32a3019c77c5f7e
Claude review output
No blockers; I'd approve. This was the sixth review round, at head 47f108c. All 14 points from your round-5 review are either fixed or listed under "Known limitations" in the PR description:
- Fixed: the spaces-only query on filtered tabs, a request counter for stale responses, later pages staying on the provider that served page one, no reports for hidden listings, Retry resetting the circuit breaker, failures returned as values (the empty error class is gone), the leftover comments, and the Installed-tab test mock.
- Accepted: the shared registry error message, no cancelling of outdated requests, evicting failures instead of not caching them, and
trimEnd.
I traced the new request counter against the queue's merge behaviour, the later-page pinning in the gateway, and resetCircuits(), and found no correctness bugs.
Checks
- CI on
47f108c: 94 passed, 27 skipped, none failing. The PR has no conflicts; it's only waiting on approval. - I installed dependencies in the review checkout and ran the 10 touched test files: 286 tests pass.
Optional findings
-
Cached results re-arm the error-report limit while offline (
useRegistrySearch.ts:129). Any successful result clearsfailureReportedSinceSuccess, and both providers return success from their caches without a network call. I checked this with a throwaway test against the real gateway and providers (now deleted). I went offline after the empty listing had loaded and cached, then switched the query betweenggufand''five times. Each of the 3 failures sent a report. It only happens when the user switches queries, not on every keystroke, so it's minor. It's worth a line under "Known limitations", or a flag marking cached results so they don't count as a recovery. -
The Algolia provider's
trycovers more than the client call (algoliaSearchProvider.ts:203). It wraps the PR's ownsearchPacksInternalrather than justsearchClient.searchat line 152.error-handling.md§2 lists that as a warning sign, and the PR description says it "converts at its client call", which isn't what the code does. In practice, a bug in the mapping code would show up as an Algolia failure and silently fall back to the registry, with only aconsole.warn. -
Test variable names (
useRegistrySearch.test.ts:219,:657):rejectStaleSearchandrejectSearchnow resolve to{ ok: false }, and nothing rejects anymore. -
PR description: it's about 18.6k characters, with a section for each review round, and it becomes the squash commit body. AGENTS.md asks for extremely concise descriptions. The title still says "four" edge cases. It should be condensed before merge.
I haven't posted anything to GitHub. I can post this as a review comment if you want.
Verification and final-look handoff
Claude explicitly found no blockers. All four remaining notes above are optional; this review does not request another code-change round for those notes. Ben retains final approval and merge decisions.
The saved test output confirms 10 test files and 286 tests passed; Claude also ran the temporary one-test cache-reporting check described above. GitHub checks were independently verified green on this exact head, and GitHub reports it mergeable. Independent focused Node harnesses against the actual gateway/provider source also verify that later-page failure does not switch providers and that explicit circuit reset reaches a recovered provider. Source inspection confirms tab filtering receives the trimmed query. These checks are separate from a full browser exercise.
Mapping bugs now throw instead of looking like an Algolia outage and silently failing over to the registry. Rename test helpers that no longer reject.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
Reviewed head: 2c0c8d3ba5f39b6ba70b58c27be6b5948f68fc1d
Reviewed base: 5264a9d2421bb9ab2e85c8efcbe291ef17d179c7
Accepted live base: 87479f69ee9d43fb561b8b22ffad6c56b4fe36d4
Claude final verdict
I reviewed PR #21154 (head 2c0c8d3, 19 files, +1709/−414) and found one real regression that should be fixed before merge. CI is green: 94 checks pass, 27 skipped. I didn't run the tests locally because this checkout has no node_modules, so everything below comes from reading the code. Nothing was posted to the PR.
Should fix before merge
1. Errors thrown inside a provider are now swallowed silently.
- The bug: the old
try/catchblocks are gone from bothdoLoadMoreand the gateway. The PR deliberately lets a bad Algolia response throw: the new test atsrc/services/providers/algoliaSearchProvider.test.ts:317expects aTypeError"instead of failing over". - Where it ends up: nothing catches that error except
usePreemptableQueue, whose.catch(() => undefined)atsrc/utils/pagedList.ts:132throws it away.docs/guidance/error-handling.md§6 says to know which handler will catch a throw before you write it; here that handler drops the error. - First page: the search call at
useRegistrySearch.ts:121rejects, sofirstPagestaysloading.isFirstPagePendingstays true and the skeleton shows forever, with no error message, no Retry button and noreportErrorcall. - Later pages:
morePagesstays true, socanLoadMorePacksturns true again once loading stops.useInfiniteScrollinVirtualGrid.vue:132then callsloadMoreabout every 100 ms while the list is scrolled to the bottom. Algolia doesn't cache a response that throws, so each retry is a real network request. - Gateway: at
registrySearchGateway.ts:147, a throwing provider no longer falls back to the registry and never counts toward the circuit breaker. Before this PR, the gateway caught the error, counted it and served registry results. - Suggested fix: the Algolia response is untrusted network data, so check its shape where it's read (
algoliaSearchProvider.ts:173,results[0]/.hits). A malformed response should come back as{ ok: false, cause }, and the test should then expect a fallback to the registry rather than a throw. That one change fixes all three symptoms.
Worth fixing
2. The "all providers failed" error loses the original errors (registrySearchGateway.ts:164-169).
- It builds a new
Errorfrom the last provider's message, with nocause.reportErrorreceives an error whose stack trace points at the gateway, and the Algolia error is dropped. - Passing
{ cause: lastError }would fix most of this; anAggregateErrorwould keep the errors from both providers.
3. Leftover comments break AGENTS.md's "Delete the existing comments in any function you modify".
useCachedRequest.ts:51still says// Set cache on error to prevent retrying bad requests. That's now wrong for this caller, because the newevictexists precisely so the request gets retried.- The internal JSDoc blocks at lines 77–79 and 86–88 aren't on an exported API, so the rule doesn't allow them either.
ManagerDialog.vue:435and:446still have comments; the PR removed two neighbouring ones.
Older problems this PR builds on (good follow-ups)
- Algolia stays demoted after one failure (
registrySearchGateway.ts:105,:114-118). A single Algolia error movesactiveProviderIndexto the registry for the rest of the session, even though Algolia's circuit is still closed. Searches then lose Algolia suggestions and query rewrites until the registry also fails or the user clicks Retry. This behaviour predates the PR, but the new JSDoc ("through the first available provider") says otherwise. - Failed requests cached as null. The PR evicts
nullentries from the search provider only. The root fix is to stopuseCachedRequestcaching failures at all, which would also fixgetPackByIdand the other callers. The PR already lists this as a known limitation. - Cancelled requests would look like failures. If a request is cancelled, the service returns
null, which the provider now treats as a failed search. Nothing callsregistryStore.cancelRequests()today, so this can't happen yet. - Small cleanups:
ProviderState.isHealthyandlastErrorare written but never read.CachedRegistryRequest(registrySearchProvider.ts:11) repeats the typeuseCachedRequestalready returns.- The
succeeded/failedtest helpers are copied across four test files.
Looks good
- The
searchQueryUtil.tsrewrite is correct and runs in linear time. I checkedowner/repo /,repo.git/,.gitand repeated.git.git. The old regex that backtracked badly on long slugs is gone, and which slugs count as compound repo names is unchanged. - The generation counter in
useRegistrySearchcorrectly throws away out-of-date page loads during a query change. - While the user is typing,
isFirstPagePendingshows the skeleton rather than briefly flashing "No results found".
I can post these as inline comments on the PR if you want.
Original detailed review pass
All 14 source-based candidates from the detailed pass are retained below. The final verdict above supplies the final classifications: one should-fix regression, with the rest described as worthwhile fixes, older follow-ups or cleanup. This is not a request to fix every candidate.
[
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 121,
"summary": "doLoadMore no longer catches errors, and the PR now lets provider bugs propagate as throws (the Algolia mapping bug is deliberately rethrown); usePreemptableQueue discards the rejection with `.catch(() => undefined)`, so firstPage stays 'loading' forever and nothing is reported.",
"failure_scenario": "Algolia resolves an unexpected shape (e.g. `{ results: [] }`, the case in the test 'throws a bug in mapping the response'). searchPacks rejects, loadCurrentFirstPage rejects, the queue swallows it, and firstPage stays `{status:'loading'}`. In ManagerDialog isFirstPagePending stays true, so GridSkeleton shows forever with no error state, no Retry and no reportError or console output. Before the PR the error was caught, logged, and morePages was set to false."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 153,
"summary": "A throw while loading a later page is swallowed by the queue before applyFailure runs, so morePages stays true and VirtualGrid's useInfiniteScroll keeps calling loadMore again after each attempt settles.",
"failure_scenario": "The user scrolls to page 2 and the provider throws (the same mapping bug on a later response). loadMore resolves false, hasMore stays true, isSearchLoading goes back to false, canLoadMorePacks is true, and useInfiniteScroll rechecks after its ~100 ms interval. The result is an endless loop of Algolia requests about 10 times a second while the grid stays scrolled to the bottom. The old catch set morePages=false, which stopped it."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 147,
"summary": "The gateway's try/catch around provider.searchPacks was removed, so a provider that throws (instead of resolving ok:false) aborts the whole search: no failover to the next provider, no recordFailure, and the gateway's own promise rejects.",
"failure_scenario": "Algolia's mapping throws a TypeError on a malformed response. Before, the gateway caught it, counted a failure, and served registry results. Now the rejection escapes searchPacks, the registry is never asked, the circuit never opens, and every later search hits the same throw."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 105,
"summary": "findUntriedProvider always tries providers[activeProviderIndex] first, and updateActiveProviderOnFailure moves that index to the registry after a single Algolia failure, so one blip demotes Algolia for the rest of the session even though its circuit is still closed.",
"failure_scenario": "Algolia fails once (consecutiveFailures=1, below the threshold of 3) and the registry serves the result, leaving activeProviderIndex=1. Every later search in that dialog goes to the registry first and succeeds, so Algolia is never asked again until the registry fails or the user clicks Retry. Users lose query suggestions, query rewrites, Algolia ranking and the rawResultsEmpty signal behind the legacy-manager tip. This contradicts the new JSDoc, 'through the first available provider'."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 149,
"summary": "recordSuccess runs for any ok outcome, including Algolia's module-level cache hits that made no network request, so a cached query resets Algolia's consecutiveFailures and its circuit never opens while offline.",
"failure_scenario": "Offline, the user alternates between new queries and earlier, cached ones (e.g. backspacing). Each cached query resets Algolia's failures to 0, so the threshold of 3 is never reached. Every new query waits for the Algolia lite client's full multi-host timeout before failing over, instead of skipping Algolia once the circuit is open."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 167,
"summary": "The all-providers-failed result builds a new Error from the last provider's message only: the original Error objects (stack, ApiError status) are dropped, there is no `cause`, earlier providers' errors are discarded, and `||` turns an empty message into 'No available search providers'.",
"failure_scenario": "Algolia fails with an ApiError (status 403, e.g. a revoked key) and the registry fails with a network error. reportError receives a synthesized Error whose stack points at the gateway and whose text mentions only the registry, so the Algolia outage never reaches telemetry. A provider error with message '' is reported as 'No available search providers' even though providers were tried."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 157,
"summary": "When Algolia fails and the registry fallback succeeds, the Algolia failure is only console.warn'd and never passed to reportError, so a degraded search is invisible in telemetry (error-handling.md: report at the ownership boundary; a catch whose only statement is console output is a 'tell').",
"failure_scenario": "Algolia is down or rate-limited for all users. Every search silently falls back to the registry (no suggestions, worse ranking, no rewrites), and neither Datadog nor Sentry records anything, because useRegistrySearch only reports when every provider failed."
},
{
"file": "src/services/providers/registrySearchProvider.ts",
"line": 40,
"summary": "Treating every null from useCachedRequest as a failure also turns cancelled requests into errors: comfyRegistryService returns null for aborts (isAbortError), and useCachedRequest.cancel() aborts in-flight calls.",
"failure_scenario": "registryStore.cancelRequests() (which calls listAllPacks.cancel()) runs while the opening listing is in flight. The service returns null for the abort, the provider builds 'Comfy Registry request failed', the gateway returns ok:false, and the dialog shows 'Error connecting to the Comfy Node Registry' and reports a warning for a deliberate cancellation. cancelRequests has no caller today, so this is latent."
},
{
"file": "src/services/providers/registrySearchProvider.ts",
"line": 41,
"summary": "Altitude: evict-on-null is a special case added on top of useCachedRequest, which still caches every failure as null ('Set cache on error to prevent retrying bad requests'). The root fix is to stop caching null and failed results in useCachedRequest itself.",
"failure_scenario": "Only this provider recovers from transient failures. getPackById, inferPackFromNodeName and getNodeDefs keep a single network blip cached as null for the whole session (the PR lists this as a known limitation), and the new evict API plus per-caller eviction is extra surface to maintain."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 137,
"summary": "Altitude: the generation counter plus the recursive loadCurrentFirstPage rerun work around usePreemptableQueue.preempt merging a new preempt into the one already running (which then runs with stale inputs), and the queue's AbortSignal is ignored.",
"failure_scenario": "Each debounced edit waits for the previous stale request to finish before searching the current input. useAssetsQuery, the queue's other preempt user, has no such workaround. Making preempt schedule a follow-up run, and passing the signal through searchPacks to axios and Algolia, would fix both in one place."
},
{
"file": "src/workbench/extensions/manager/composables/useRegistrySearch.ts",
"line": 168,
"summary": "Efficiency: the immediate watcher fetches the registry listing on open even when isVisible is false; the new isVisible input only gates reporting, not the request.",
"failure_scenario": "Opening the dialog on Installed, Updates, Conflicting, Workflow or Missing with an empty query still sends an Algolia/registry listing request nobody sees. Offline, it also adds failures toward the circuit breaker, so a later visible search can find the circuits already open."
},
{
"file": "src/services/gateway/registrySearchGateway.ts",
"line": 14,
"summary": "Simplification: ProviderState.isHealthy and lastError are written (in recordSuccess, recordFailure and now resetCircuits) but never read, and isHealthy duplicates `consecutiveFailures >= CIRCUIT_BREAKER_THRESHOLD`. Pinning is also expressed indirectly by putting every other provider in a skip Set.",
"failure_scenario": "The dead state and the inverted skip Set make the circuit and pinning logic harder to follow. Calling the pinned provider directly when pageNumber > 0, and dropping the unread fields, does the same job with less code."
},
{
"file": "src/services/providers/registrySearchProvider.ts",
"line": 11,
"summary": "Reuse: CachedRegistryRequest re-declares the call/evict signature that useCachedRequest already returns. The `succeeded`/`failed` outcome builders are also copied across four test files (gateway, useRegistrySearch, ManagerDialog, registrySearchProvider).",
"failure_scenario": "If useCachedRequest's return type changes, the hand-written interface can drift silently. `Pick<ReturnType<typeof useCachedRequest<TParams, TResult>>, 'call' | 'evict'>` and a shared test builder for SearchPacksOutcome would remove the copies."
},
{
"file": "src/composables/useCachedRequest.ts",
"line": 51,
"summary": "AGENTS.md (repo root) says 'Delete the existing comments in any function you modify.' The PR modifies useCachedRequest (adds evict) but leaves `// Set cache on error to prevent retrying bad requests` and the inner JSDoc blocks ('Cancel and clear any pending requests', 'Cached version of the request function'). ManagerDialog.vue's modified script setup also keeps `// Tab helpers for template` (line 435) and `// Map of tab IDs to their empty state i18n key suffixes` (line 446).",
"failure_scenario": "Breaks the quoted project rule in AGENTS.md. The remaining comment also misstates the new behaviour, since the search provider now evicts that cached failure so it is retried."
}
]Independent verification and limits
Claude did not produce an explicit Blocking heading, so its original classifications and all content stay in these details.
The unresolved first-page error path was reproduced in a focused Node harness executing the actual useRegistrySearch and usePreemptableQueue source, with ref/computed/watch substitutes and a gateway that throws a TypeError like the response-mapping case deliberately asserted by algoliaSearchProvider.test.ts. After the queue settled, the result was: providerCalls=1, errorReports=0, queueRunning=false, firstPageStatus=loading, itemCount=0, hasMore=true. Source inspection confirms the dialog keeps its skeleton for that pending first page. This verifies behavior conditional on a provider exception; it does not claim a live malformed Algolia response was observed or that normal network failures (returned as values) trigger it. No browser or automatic infinite-scroll reproduction was run.
The prior gateway checks still pass: later-page failure stays pinned to the original provider, and explicit circuit reset reaches a recovered provider. GitHub checks were independently verified green on this exact head. No full local test-suite pass is claimed for this revision; verification here was the focused Node harnesses and source inspection. The base-only #16349 adds two CRDT dev-panel tests, with no runtime or PR-file overlap. Effective diff remains identical at both bases: 116,833 bytes, SHA-256 1d344c2846f288776253d8fc18ad4f295e4e5f9f559865a6cfea11ce70da560b.
Validate the Algolia results before mapping them, so a malformed response
returns { ok: false, cause } and the gateway falls back to the registry
instead of throwing into the search queue and leaving the first page
loading. Rewrite responses are validated the same way and degrade to the
raw results.
When every provider fails, the gateway cause is now an AggregateError of
each provider's error. Remove leftover comments in useCachedRequest and
ManagerDialog.
Validate the registry search and list responses before mapping them, so a
200 without a nodes list returns { ok: false, cause } instead of throwing
into the search queue and leaving the first page broken. The malformed
page is evicted from the request cache so Retry asks the registry again.
benceruleanlu
left a comment
There was a problem hiding this comment.
This review was performed agentically. Ben will be notified to review manually soon.
Review details
0 blocking findings
This PR changes the custom-node pack browser (the Manager dialog). Searches go first to Algolia, a hosted search service, and fall back to the Comfy Registry API. The code that picks between them is registrySearchGateway.ts. On main today, a failed registry request quietly turns into an empty list. If both services are down, users see "No results found" and nothing reaches telemetry. With this PR, a failed search shows "Error connecting to the Comfy Node Registry" with a Retry button and is reported once. Results from an outdated query or mode are dropped. I recommend merging. I found nothing blocking, and all CI checks pass on the reviewed commit (c17dcd64).
Blocking
None.
Optional
None.
Checked
- Real "no results" searches don't become errors. The registry fallback now treats a missing response, or one without a
nodeslist, as a failure. The generated API types marknodesas optional, so I queried the live registry. An empty search, an empty node-name search, and pages past the end all return"nodes": [], so they still show "No results found". - Cancelled requests don't show as failures. The registry service returns nothing on a cancelled request, which the new code would count as a failure. The only code that cancels registry requests is
cancelRequestsincomfyRegistryStore.ts, and nothing calls it. - No other code depends on the old return type. Search now returns a success/failure value instead of throwing. Nothing outside the gateway, the two providers and
useRegistrySearch.ts(the composable behind the dialog's results) calls these functions. - Overlapping searches. I traced a mode or query change made while the first page, or a later page, is still loading, using the existing request queue in
src/utils/pagedList.ts. The old response is dropped, the list clears right away, and the new search reruns. Later pages stay with whichever service answered page one. - Query cleanup. The rewritten owner/repo pattern accepts exactly the same queries as the old one. Queries that clean down to nothing (like
/or.git /) are filtered out, so they can't send an empty search that would list every pack. - The error screen. The
g.retryandmanager.errorConnectingstrings exist, and the empty-state component accepts the new button label and click handler. - Tests. The 10 touched test files pass locally (298 tests).
- Not checked: I didn't run the app or e2e tests.
- Theoretical gap: the gateway no longer catches errors thrown inside a provider. An unexpected throw would leave the loading skeleton up with no report. I found no realistic source, since both providers catch errors where they call the network.
Reviewed target and additional validation
- Reviewed head:
c17dcd647a10a216d1f9c456987d9208af552539. - Actual
maintip:8750ae96274018d9d69915ed8995cf6fd234586a. - Fresh review round 1 used
claude-opus-5-5atxhigh, with the exactReview https://github.com/Comfy-Org/ComfyUI_frontend/pull/21154prompt and only Ben's fixed rules appended through the system prompt. Original output, commands, system prompt, and visible reviewer evidence are retained. - Independently reran all 298 tests across the 10 changed test files, with retries disabled and two workers. All passed. Targeted
oxlint --type-awarealso passed for the changed TypeScript and Vue files. These tests overlap Claude's check above; they are not additional distinct coverage. - GitHub check snapshot: 94 SUCCESS, 29 SKIPPED, with no failures or pending checks in that snapshot. The review decision was unset; this publication is a COMMENT review.
- No live app interaction or local E2E suite was run. Claude's unexpected-provider-throw observation remains a theoretical limitation, with no realistic source identified, and is not promoted to a blocking finding.
…d packs (Comfy-Org#21448) ## Summary When a second-or-later page of Manager search results failed, pagination ended with no message. Comfy-Org#21154 added a retry for the initial search only. Now the loaded cards, scroll position and selection stay as they were, and a notice with a Retry button appears below the grid. Retry loads the same page for the same query and mode. - `useRegistrySearch`: a later-page failure sets `isNextPageFailed` instead of `morePages = false`. While it is set, `hasMore` is false, so infinite scroll stops calling. `retryNextPage()` resets the provider circuits and runs through the existing `loadMore` queue, so concurrent retries and scroll loads share one request. The gateway already pins later pages to the provider that served page 0, so a retry goes to the same provider. A query or mode change bumps the generation as before, so a retry that lands afterwards is dropped. - `ManagerDialog`: the notice uses the shared `Message` component (warning). It sits outside the grid's click-to-deselect area, so clicking Retry keeps the selection. It is hidden while a newer query is still debouncing. - Scope: OSS/Desktop native Manager only. No backend or Cloud changes. - While a page is failed, scroll loads don't request it again; only Retry does. If a tab filters out every loaded pack (Not Installed with every page-1 pack installed), the grid and notice stay instead of the "No results" empty state, and the legacy-manager tip waits until no pages are pending. - If the retry fails again and focus was lost when the notice unmounted, focus returns to Retry. ## Screenshots All Extensions tab, with the second results page failing (mocked registry, page size 64). | Before: pagination stops after Paged Pack 63 with no message | After: cards stay and a notice offers Retry | | --- | --- | | <img width="2880" height="1800" alt="before-failed" src="https://github.com/user-attachments/assets/b3b4cd6d-cd19-4e00-905c-64cc7521c257" /> | <img width="2880" height="1800" alt="after-failed" src="https://github.com/user-attachments/assets/eb83e8c2-2e9f-4b97-9132-608e03847de8" />| After Retry, the same page loads and the list continues to Paged Pack 79: <img width="2880" height="1800" alt="after-retried" src="https://github.com/user-attachments/assets/a482e5d6-9f8a-40fe-b31b-a4525f1735cd" /> ## Verification - Reproduced in a real browser (Playwright, Chromium, local dev server, mocked Algolia/registry): on `main`, after the second page fails, no notice or retry appears and pagination stops. The new E2E `ManagerDialog › Failed next page` fails on `main` and passes with the fix. - Unit (`useRegistrySearch.test.ts`): kept cards and paused pagination; retry requests the same query, page and attributes; duplicate retries and scroll loads make one request; a retry landing after a mode change is dropped. To prove the dedup and stale tests catch regressions, I made `retryNextPage` bypass the queue and confirmed both tests fail. - Component (`ManagerDialog.test.ts`): notice and Retry show below the kept cards, and Retry appends page 2. - `vitest run src/workbench/extensions/manager`: 605/605 pass. Each later fix has a test that fails without it. - Full `managerDialog.spec.ts` locally: 11 passed. 3 others failed in `beforeEach` with "app never became ready" on a local dev server, and these were different tests on each run, none of them touching this change. - The E2E run above used the first commit. The second commit only moves the notice into `Message`. Re-running E2E after it was blocked because the local backend stopped (`Failed to retrieve users`). The unit and component tests and the pre-commit/pre-push hooks pass on the final tree. CI is the authority.
Requested by Christian Byrne · Slack thread
Summary
Follow-up to #21133: Manager pack search now shows failures instead of empty results, and the "Looking for ComfyUI-Manager?" tip and query rewrites handle more edge cases.
owner/repo /queries rewrote badly, and a long pasted slug took about 1 s./is stripped, and long slugs are matched in linear time.How: providers return
{ ok: true, result } | { ok: false, cause }instead of throwing; the registry provider fails on a null or malformed response and evicts that cache entry, and Algolia also fails on a malformed response, so the gateway falls back to the registry. When every provider fails, the cause is anAggregateErrorof each provider's error. The gateway tries each provider once per search, pins later pages to the provider of page one, and exposesresetCircuits()for Retry.useRegistrySearchtracks a request generation, drops stale responses and reruns for the current inputs, and exposes the first page as loading, failed or loaded.Known limitations:
useCachedRequeststill caches failures asnullfor its other callers.analyticsTagsare not in the cache key, so a cached repeat logs no analytics event.Verification
Unit and integration tests cover each fix (each red without it), including a real gateway, providers and registry service over a mocked axios adapter.
pnpm typecheck, lint andoxfmt --checkpass; the 10 touched test files pass (298 tests).