根据AI意见修正

Author: cyfung1031

src/app/service/service_worker/resource.ts

@@ -297,6 +297,9 @@ export class ResourceService {
   async createResourceByUrlFetch(u: TUrlSRIInfo, type: ResourceType): Promise<Resource> {
     const url = u.url; // 无 URI Integrity Hash
 
+    // 随机抖动：分散对同一 server 的请求启动时间，降低被限速的概率
+    await sleep(randNum(FETCH_JITTER_MIN_MS, FETCH_JITTER_MAX_MS));
+
     // 等待并发槽位（滑动窗口入口）
     await concurrentFetchSlots.acquire();
 
@@ -309,18 +312,19 @@ export class ResourceService {
       }
     };
 
-    // 随机抖动：分散对同一 server 的请求启动时间，降低被限速的概率
-    await sleep(randNum(FETCH_JITTER_MIN_MS, FETCH_JITTER_MAX_MS));
-
     // 滑动窗口语义：
     //   - fetch 超时 (timeouted=true)  → 提前归还槽位，下一个请求可以启动
-    //   - fetch 完成/失败 (done=true)  → 归还槽位（若 timeout 已归还则为 no-op）
+    //   - fetch 完成/失败 (settled=true)  → 归还槽位（若 timeout 已归还则为 no-op）
     // 原 fetch 在超时后仍继续运行，响应到达时照常处理（不会被取消）
-    const { result, err } = await withTimeoutNotify(fetch(url), FETCH_SLOT_SLIDE_TIMEOUT_MS, ({ done, timeouted }) => {
-      if (timeouted || done) {
-        releaseSlotOnce();
+    const { result, err } = await withTimeoutNotify(
+      fetch(url),
+      FETCH_SLOT_SLIDE_TIMEOUT_MS,
+      ({ settled, timeouted }) => {
+        if (timeouted || settled) {
+          releaseSlotOnce();
+        }
       }
-    });
+    );
 
     if (err) {
       throw new Error(`resource fetch failed: ${err.message || err}`);

src/pkg/utils/concurrency-control.test.ts

@@ -96,35 +96,35 @@ describe("Semaphore", () => {
 });
 
 describe("withTimeoutNotify", () => {
-  it.concurrent("promise 在超时前完成时，回调收到 done=true", async () => {
+  it.concurrent("promise 在超时前完成时，回调收到 settled=true", async () => {
     const promise = Promise.resolve("ok");
-    const calls: Array<{ done: boolean; timeouted: boolean }> = [];
+    const calls: Array<{ settled: boolean; timeouted: boolean }> = [];
 
     const res = await withTimeoutNotify(promise, 1000, (r) => {
-      calls.push({ done: r.done, timeouted: r.timeouted });
+      calls.push({ settled: r.settled, timeouted: r.timeouted });
     });
 
     expect(res.result).toBe("ok");
-    expect(res.done).toBe(true);
+    expect(res.settled).toBe(true);
     expect(res.timeouted).toBe(false);
     expect(res.err).toBeUndefined();
     // 只调用一次（done），不触发 timeout
-    expect(calls).toEqual([{ done: true, timeouted: false }]);
+    expect(calls).toEqual([{ settled: true, timeouted: false }]);
   });
 
   it.concurrent("promise 在超时前失败时，回调收到 err", async () => {
     const error = new Error("fail");
     const promise = Promise.reject(error);
-    const calls: Array<{ done: boolean; err: Error | undefined }> = [];
+    const calls: Array<{ settled: boolean; err: Error | undefined }> = [];
 
     const res = await withTimeoutNotify(promise, 1000, (r) => {
-      calls.push({ done: r.done, err: r.err });
+      calls.push({ settled: r.settled, err: r.err });
     });
 
     expect(res.err).toBe(error);
-    expect(res.done).toBe(true);
+    expect(res.settled).toBe(true);
     expect(res.result).toBeUndefined();
-    expect(calls).toEqual([{ done: true, err: error }]);
+    expect(calls).toEqual([{ settled: true, err: error }]);
   });
 
   it.concurrent("超时后回调被调用，promise 完成后再次调用", async () => {
@@ -133,26 +133,26 @@ describe("withTimeoutNotify", () => {
     const promise = new Promise<string>((r) => {
       resolvePromise = r;
     });
-    const calls: Array<{ done: boolean; timeouted: boolean }> = [];
+    const calls: Array<{ settled: boolean; timeouted: boolean }> = [];
 
     const resultPromise = withTimeoutNotify(promise, 100, (r) => {
-      calls.push({ done: r.done, timeouted: r.timeouted });
+      calls.push({ settled: r.settled, timeouted: r.timeouted });
     });
 
     // 触发超时
     vi.advanceTimersByTime(100);
-    expect(calls).toEqual([{ done: false, timeouted: true }]);
+    expect(calls).toEqual([{ settled: false, timeouted: true }]);
 
     // promise 完成
     resolvePromise!("late");
     const res = await resultPromise;
 
     expect(res.result).toBe("late");
-    expect(res.done).toBe(true);
+    expect(res.settled).toBe(true);
     expect(res.timeouted).toBe(true);
-    // 回调被调用两次：timeout + done
+    // 回调被调用两次：timeout + settled
     expect(calls).toHaveLength(2);
-    expect(calls[1]).toEqual({ done: true, timeouted: true });
+    expect(calls[1]).toEqual({ settled: true, timeouted: true });
 
     vi.useRealTimers();
   });

src/pkg/utils/concurrency-control.ts

@@ -26,7 +26,7 @@ export class Semaphore {
 type TWithTimeoutNotifyResult<T> = {
   timeouted: boolean;
   result: T | undefined;
-  done: boolean;
+  settled: boolean;
   err: undefined | Error;
 };
 export const withTimeoutNotify = <T>(
@@ -43,14 +43,14 @@ export const withTimeoutNotify = <T>(
     .then((result: T) => {
       clearTimeout(cid);
       res.result = result;
-      res.done = true;
+      res.settled = true;
       fn(res);
       return res;
     })
     .catch((e) => {
       clearTimeout(cid);
       res.err = e;
-      res.done = true;
+      res.settled = true;
       fn(res);
       return res;
     });